xref: /aosp_15_r20/external/vulkan-headers/include/vulkan/vulkan_handles.hpp (revision 902771965e4c6d39c75c62130a6a330c08b024db) 
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 // include-what-you-use: make sure, vulkan.hpp is used by code-completers
12 // IWYU pragma: private; include "vulkan.hpp"
13 
14 namespace VULKAN_HPP_NAMESPACE
15 {
16 
17   //===================================
18   //=== STRUCT forward declarations ===
19   //===================================
20 
21   //=== VK_VERSION_1_0 ===
22   struct Extent2D;
23   struct Extent3D;
24   struct Offset2D;
25   struct Offset3D;
26   struct Rect2D;
27   struct BaseInStructure;
28   struct BaseOutStructure;
29   struct BufferMemoryBarrier;
30   struct DispatchIndirectCommand;
31   struct DrawIndexedIndirectCommand;
32   struct DrawIndirectCommand;
33   struct ImageMemoryBarrier;
34   struct MemoryBarrier;
35   struct PipelineCacheHeaderVersionOne;
36   struct AllocationCallbacks;
37   struct ApplicationInfo;
38   struct FormatProperties;
39   struct ImageFormatProperties;
40   struct InstanceCreateInfo;
41   struct MemoryHeap;
42   struct MemoryType;
43   struct PhysicalDeviceFeatures;
44   struct PhysicalDeviceLimits;
45   struct PhysicalDeviceMemoryProperties;
46   struct PhysicalDeviceProperties;
47   struct PhysicalDeviceSparseProperties;
48   struct QueueFamilyProperties;
49   struct DeviceCreateInfo;
50   struct DeviceQueueCreateInfo;
51   struct ExtensionProperties;
52   struct LayerProperties;
53   struct SubmitInfo;
54   struct MappedMemoryRange;
55   struct MemoryAllocateInfo;
56   struct MemoryRequirements;
57   struct BindSparseInfo;
58   struct ImageSubresource;
59   struct SparseBufferMemoryBindInfo;
60   struct SparseImageFormatProperties;
61   struct SparseImageMemoryBind;
62   struct SparseImageMemoryBindInfo;
63   struct SparseImageMemoryRequirements;
64   struct SparseImageOpaqueMemoryBindInfo;
65   struct SparseMemoryBind;
66   struct FenceCreateInfo;
67   struct SemaphoreCreateInfo;
68   struct EventCreateInfo;
69   struct QueryPoolCreateInfo;
70   struct BufferCreateInfo;
71   struct BufferViewCreateInfo;
72   struct ImageCreateInfo;
73   struct SubresourceLayout;
74   struct ComponentMapping;
75   struct ImageSubresourceRange;
76   struct ImageViewCreateInfo;
77   struct ShaderModuleCreateInfo;
78   struct PipelineCacheCreateInfo;
79   struct ComputePipelineCreateInfo;
80   struct GraphicsPipelineCreateInfo;
81   struct PipelineColorBlendAttachmentState;
82   struct PipelineColorBlendStateCreateInfo;
83   struct PipelineDepthStencilStateCreateInfo;
84   struct PipelineDynamicStateCreateInfo;
85   struct PipelineInputAssemblyStateCreateInfo;
86   struct PipelineMultisampleStateCreateInfo;
87   struct PipelineRasterizationStateCreateInfo;
88   struct PipelineShaderStageCreateInfo;
89   struct PipelineTessellationStateCreateInfo;
90   struct PipelineVertexInputStateCreateInfo;
91   struct PipelineViewportStateCreateInfo;
92   struct SpecializationInfo;
93   struct SpecializationMapEntry;
94   struct StencilOpState;
95   struct VertexInputAttributeDescription;
96   struct VertexInputBindingDescription;
97   struct Viewport;
98   struct PipelineLayoutCreateInfo;
99   struct PushConstantRange;
100   struct SamplerCreateInfo;
101   struct CopyDescriptorSet;
102   struct DescriptorBufferInfo;
103   struct DescriptorImageInfo;
104   struct DescriptorPoolCreateInfo;
105   struct DescriptorPoolSize;
106   struct DescriptorSetAllocateInfo;
107   struct DescriptorSetLayoutBinding;
108   struct DescriptorSetLayoutCreateInfo;
109   struct WriteDescriptorSet;
110   struct AttachmentDescription;
111   struct AttachmentReference;
112   struct FramebufferCreateInfo;
113   struct RenderPassCreateInfo;
114   struct SubpassDependency;
115   struct SubpassDescription;
116   struct CommandPoolCreateInfo;
117   struct CommandBufferAllocateInfo;
118   struct CommandBufferBeginInfo;
119   struct CommandBufferInheritanceInfo;
120   struct BufferCopy;
121   struct BufferImageCopy;
122   struct ClearAttachment;
123   union ClearColorValue;
124   struct ClearDepthStencilValue;
125   struct ClearRect;
126   union ClearValue;
127   struct ImageBlit;
128   struct ImageCopy;
129   struct ImageResolve;
130   struct ImageSubresourceLayers;
131   struct RenderPassBeginInfo;
132 
133   //=== VK_VERSION_1_1 ===
134   struct PhysicalDeviceSubgroupProperties;
135   struct BindBufferMemoryInfo;
136   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
137   struct BindImageMemoryInfo;
138   using BindImageMemoryInfoKHR = BindImageMemoryInfo;
139   struct PhysicalDevice16BitStorageFeatures;
140   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
141   struct MemoryDedicatedRequirements;
142   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
143   struct MemoryDedicatedAllocateInfo;
144   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
145   struct MemoryAllocateFlagsInfo;
146   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
147   struct DeviceGroupRenderPassBeginInfo;
148   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
149   struct DeviceGroupCommandBufferBeginInfo;
150   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
151   struct DeviceGroupSubmitInfo;
152   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
153   struct DeviceGroupBindSparseInfo;
154   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
155   struct BindBufferMemoryDeviceGroupInfo;
156   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
157   struct BindImageMemoryDeviceGroupInfo;
158   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
159   struct PhysicalDeviceGroupProperties;
160   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
161   struct DeviceGroupDeviceCreateInfo;
162   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
163   struct BufferMemoryRequirementsInfo2;
164   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
165   struct ImageMemoryRequirementsInfo2;
166   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
167   struct ImageSparseMemoryRequirementsInfo2;
168   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
169   struct MemoryRequirements2;
170   using MemoryRequirements2KHR = MemoryRequirements2;
171   struct SparseImageMemoryRequirements2;
172   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
173   struct PhysicalDeviceFeatures2;
174   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
175   struct PhysicalDeviceProperties2;
176   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
177   struct FormatProperties2;
178   using FormatProperties2KHR = FormatProperties2;
179   struct ImageFormatProperties2;
180   using ImageFormatProperties2KHR = ImageFormatProperties2;
181   struct PhysicalDeviceImageFormatInfo2;
182   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
183   struct QueueFamilyProperties2;
184   using QueueFamilyProperties2KHR = QueueFamilyProperties2;
185   struct PhysicalDeviceMemoryProperties2;
186   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
187   struct SparseImageFormatProperties2;
188   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
189   struct PhysicalDeviceSparseImageFormatInfo2;
190   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
191   struct PhysicalDevicePointClippingProperties;
192   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
193   struct RenderPassInputAttachmentAspectCreateInfo;
194   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
195   struct InputAttachmentAspectReference;
196   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
197   struct ImageViewUsageCreateInfo;
198   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
199   struct PipelineTessellationDomainOriginStateCreateInfo;
200   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
201   struct RenderPassMultiviewCreateInfo;
202   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
203   struct PhysicalDeviceMultiviewFeatures;
204   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
205   struct PhysicalDeviceMultiviewProperties;
206   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
207   struct PhysicalDeviceVariablePointersFeatures;
208   using PhysicalDeviceVariablePointerFeatures     = PhysicalDeviceVariablePointersFeatures;
209   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;
210   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
211   struct PhysicalDeviceProtectedMemoryFeatures;
212   struct PhysicalDeviceProtectedMemoryProperties;
213   struct DeviceQueueInfo2;
214   struct ProtectedSubmitInfo;
215   struct SamplerYcbcrConversionCreateInfo;
216   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
217   struct SamplerYcbcrConversionInfo;
218   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
219   struct BindImagePlaneMemoryInfo;
220   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
221   struct ImagePlaneMemoryRequirementsInfo;
222   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
223   struct PhysicalDeviceSamplerYcbcrConversionFeatures;
224   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
225   struct SamplerYcbcrConversionImageFormatProperties;
226   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
227   struct DescriptorUpdateTemplateEntry;
228   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
229   struct DescriptorUpdateTemplateCreateInfo;
230   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
231   struct ExternalMemoryProperties;
232   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
233   struct PhysicalDeviceExternalImageFormatInfo;
234   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
235   struct ExternalImageFormatProperties;
236   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
237   struct PhysicalDeviceExternalBufferInfo;
238   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
239   struct ExternalBufferProperties;
240   using ExternalBufferPropertiesKHR = ExternalBufferProperties;
241   struct PhysicalDeviceIDProperties;
242   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
243   struct ExternalMemoryImageCreateInfo;
244   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
245   struct ExternalMemoryBufferCreateInfo;
246   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
247   struct ExportMemoryAllocateInfo;
248   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
249   struct PhysicalDeviceExternalFenceInfo;
250   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
251   struct ExternalFenceProperties;
252   using ExternalFencePropertiesKHR = ExternalFenceProperties;
253   struct ExportFenceCreateInfo;
254   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
255   struct ExportSemaphoreCreateInfo;
256   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
257   struct PhysicalDeviceExternalSemaphoreInfo;
258   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
259   struct ExternalSemaphoreProperties;
260   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
261   struct PhysicalDeviceMaintenance3Properties;
262   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
263   struct DescriptorSetLayoutSupport;
264   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
265   struct PhysicalDeviceShaderDrawParametersFeatures;
266   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
267 
268   //=== VK_VERSION_1_2 ===
269   struct PhysicalDeviceVulkan11Features;
270   struct PhysicalDeviceVulkan11Properties;
271   struct PhysicalDeviceVulkan12Features;
272   struct PhysicalDeviceVulkan12Properties;
273   struct ImageFormatListCreateInfo;
274   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
275   struct RenderPassCreateInfo2;
276   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
277   struct AttachmentDescription2;
278   using AttachmentDescription2KHR = AttachmentDescription2;
279   struct AttachmentReference2;
280   using AttachmentReference2KHR = AttachmentReference2;
281   struct SubpassDescription2;
282   using SubpassDescription2KHR = SubpassDescription2;
283   struct SubpassDependency2;
284   using SubpassDependency2KHR = SubpassDependency2;
285   struct SubpassBeginInfo;
286   using SubpassBeginInfoKHR = SubpassBeginInfo;
287   struct SubpassEndInfo;
288   using SubpassEndInfoKHR = SubpassEndInfo;
289   struct PhysicalDevice8BitStorageFeatures;
290   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
291   struct ConformanceVersion;
292   using ConformanceVersionKHR = ConformanceVersion;
293   struct PhysicalDeviceDriverProperties;
294   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
295   struct PhysicalDeviceShaderAtomicInt64Features;
296   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
297   struct PhysicalDeviceShaderFloat16Int8Features;
298   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
299   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
300   struct PhysicalDeviceFloatControlsProperties;
301   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
302   struct DescriptorSetLayoutBindingFlagsCreateInfo;
303   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
304   struct PhysicalDeviceDescriptorIndexingFeatures;
305   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
306   struct PhysicalDeviceDescriptorIndexingProperties;
307   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
308   struct DescriptorSetVariableDescriptorCountAllocateInfo;
309   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
310   struct DescriptorSetVariableDescriptorCountLayoutSupport;
311   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
312   struct SubpassDescriptionDepthStencilResolve;
313   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
314   struct PhysicalDeviceDepthStencilResolveProperties;
315   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
316   struct PhysicalDeviceScalarBlockLayoutFeatures;
317   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
318   struct ImageStencilUsageCreateInfo;
319   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
320   struct SamplerReductionModeCreateInfo;
321   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
322   struct PhysicalDeviceSamplerFilterMinmaxProperties;
323   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
324   struct PhysicalDeviceVulkanMemoryModelFeatures;
325   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
326   struct PhysicalDeviceImagelessFramebufferFeatures;
327   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
328   struct FramebufferAttachmentsCreateInfo;
329   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
330   struct FramebufferAttachmentImageInfo;
331   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
332   struct RenderPassAttachmentBeginInfo;
333   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
334   struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
335   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
336   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
337   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
338   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
339   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
340   struct AttachmentReferenceStencilLayout;
341   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
342   struct AttachmentDescriptionStencilLayout;
343   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
344   struct PhysicalDeviceHostQueryResetFeatures;
345   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
346   struct PhysicalDeviceTimelineSemaphoreFeatures;
347   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
348   struct PhysicalDeviceTimelineSemaphoreProperties;
349   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
350   struct SemaphoreTypeCreateInfo;
351   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
352   struct TimelineSemaphoreSubmitInfo;
353   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
354   struct SemaphoreWaitInfo;
355   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
356   struct SemaphoreSignalInfo;
357   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
358   struct PhysicalDeviceBufferDeviceAddressFeatures;
359   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
360   struct BufferDeviceAddressInfo;
361   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
362   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
363   struct BufferOpaqueCaptureAddressCreateInfo;
364   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
365   struct MemoryOpaqueCaptureAddressAllocateInfo;
366   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
367   struct DeviceMemoryOpaqueCaptureAddressInfo;
368   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
369 
370   //=== VK_VERSION_1_3 ===
371   struct PhysicalDeviceVulkan13Features;
372   struct PhysicalDeviceVulkan13Properties;
373   struct PipelineCreationFeedbackCreateInfo;
374   using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
375   struct PipelineCreationFeedback;
376   using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
377   struct PhysicalDeviceShaderTerminateInvocationFeatures;
378   using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
379   struct PhysicalDeviceToolProperties;
380   using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
381   struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
382   using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
383   struct PhysicalDevicePrivateDataFeatures;
384   using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
385   struct DevicePrivateDataCreateInfo;
386   using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
387   struct PrivateDataSlotCreateInfo;
388   using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
389   struct PhysicalDevicePipelineCreationCacheControlFeatures;
390   using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
391   struct MemoryBarrier2;
392   using MemoryBarrier2KHR = MemoryBarrier2;
393   struct BufferMemoryBarrier2;
394   using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
395   struct ImageMemoryBarrier2;
396   using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
397   struct DependencyInfo;
398   using DependencyInfoKHR = DependencyInfo;
399   struct SubmitInfo2;
400   using SubmitInfo2KHR = SubmitInfo2;
401   struct SemaphoreSubmitInfo;
402   using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
403   struct CommandBufferSubmitInfo;
404   using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
405   struct PhysicalDeviceSynchronization2Features;
406   using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
407   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
408   using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
409   struct PhysicalDeviceImageRobustnessFeatures;
410   using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
411   struct CopyBufferInfo2;
412   using CopyBufferInfo2KHR = CopyBufferInfo2;
413   struct CopyImageInfo2;
414   using CopyImageInfo2KHR = CopyImageInfo2;
415   struct CopyBufferToImageInfo2;
416   using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
417   struct CopyImageToBufferInfo2;
418   using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
419   struct BlitImageInfo2;
420   using BlitImageInfo2KHR = BlitImageInfo2;
421   struct ResolveImageInfo2;
422   using ResolveImageInfo2KHR = ResolveImageInfo2;
423   struct BufferCopy2;
424   using BufferCopy2KHR = BufferCopy2;
425   struct ImageCopy2;
426   using ImageCopy2KHR = ImageCopy2;
427   struct ImageBlit2;
428   using ImageBlit2KHR = ImageBlit2;
429   struct BufferImageCopy2;
430   using BufferImageCopy2KHR = BufferImageCopy2;
431   struct ImageResolve2;
432   using ImageResolve2KHR = ImageResolve2;
433   struct PhysicalDeviceSubgroupSizeControlFeatures;
434   using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
435   struct PhysicalDeviceSubgroupSizeControlProperties;
436   using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
437   struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
438   using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
439   using ShaderRequiredSubgroupSizeCreateInfoEXT              = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
440   struct PhysicalDeviceInlineUniformBlockFeatures;
441   using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
442   struct PhysicalDeviceInlineUniformBlockProperties;
443   using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
444   struct WriteDescriptorSetInlineUniformBlock;
445   using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
446   struct DescriptorPoolInlineUniformBlockCreateInfo;
447   using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
448   struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
449   using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
450   struct RenderingInfo;
451   using RenderingInfoKHR = RenderingInfo;
452   struct RenderingAttachmentInfo;
453   using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
454   struct PipelineRenderingCreateInfo;
455   using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
456   struct PhysicalDeviceDynamicRenderingFeatures;
457   using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
458   struct CommandBufferInheritanceRenderingInfo;
459   using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
460   struct PhysicalDeviceShaderIntegerDotProductFeatures;
461   using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
462   struct PhysicalDeviceShaderIntegerDotProductProperties;
463   using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
464   struct PhysicalDeviceTexelBufferAlignmentProperties;
465   using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
466   struct FormatProperties3;
467   using FormatProperties3KHR = FormatProperties3;
468   struct PhysicalDeviceMaintenance4Features;
469   using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
470   struct PhysicalDeviceMaintenance4Properties;
471   using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
472   struct DeviceBufferMemoryRequirements;
473   using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
474   struct DeviceImageMemoryRequirements;
475   using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
476 
477   //=== VK_VERSION_1_4 ===
478   struct PhysicalDeviceVulkan14Features;
479   struct PhysicalDeviceVulkan14Properties;
480   struct DeviceQueueGlobalPriorityCreateInfo;
481   using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo;
482   using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo;
483   struct PhysicalDeviceGlobalPriorityQueryFeatures;
484   using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures;
485   using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures;
486   struct QueueFamilyGlobalPriorityProperties;
487   using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties;
488   using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties;
489   struct PhysicalDeviceShaderSubgroupRotateFeatures;
490   using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures;
491   struct PhysicalDeviceShaderFloatControls2Features;
492   using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;
493   struct PhysicalDeviceShaderExpectAssumeFeatures;
494   using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures;
495   struct PhysicalDeviceLineRasterizationFeatures;
496   using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures;
497   using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures;
498   struct PhysicalDeviceLineRasterizationProperties;
499   using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties;
500   using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties;
501   struct PipelineRasterizationLineStateCreateInfo;
502   using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo;
503   using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo;
504   struct PhysicalDeviceVertexAttributeDivisorProperties;
505   using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties;
506   struct VertexInputBindingDivisorDescription;
507   using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription;
508   using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription;
509   struct PipelineVertexInputDivisorStateCreateInfo;
510   using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo;
511   using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo;
512   struct PhysicalDeviceVertexAttributeDivisorFeatures;
513   using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures;
514   using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures;
515   struct PhysicalDeviceIndexTypeUint8Features;
516   using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features;
517   using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features;
518   struct MemoryMapInfo;
519   using MemoryMapInfoKHR = MemoryMapInfo;
520   struct MemoryUnmapInfo;
521   using MemoryUnmapInfoKHR = MemoryUnmapInfo;
522   struct PhysicalDeviceMaintenance5Features;
523   using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features;
524   struct PhysicalDeviceMaintenance5Properties;
525   using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties;
526   struct RenderingAreaInfo;
527   using RenderingAreaInfoKHR = RenderingAreaInfo;
528   struct DeviceImageSubresourceInfo;
529   using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo;
530   struct ImageSubresource2;
531   using ImageSubresource2EXT = ImageSubresource2;
532   using ImageSubresource2KHR = ImageSubresource2;
533   struct SubresourceLayout2;
534   using SubresourceLayout2EXT = SubresourceLayout2;
535   using SubresourceLayout2KHR = SubresourceLayout2;
536   struct PipelineCreateFlags2CreateInfo;
537   using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo;
538   struct BufferUsageFlags2CreateInfo;
539   using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo;
540   struct PhysicalDevicePushDescriptorProperties;
541   using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties;
542   struct PhysicalDeviceDynamicRenderingLocalReadFeatures;
543   using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures;
544   struct RenderingAttachmentLocationInfo;
545   using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;
546   struct RenderingInputAttachmentIndexInfo;
547   using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo;
548   struct PhysicalDeviceMaintenance6Features;
549   using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features;
550   struct PhysicalDeviceMaintenance6Properties;
551   using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties;
552   struct BindMemoryStatus;
553   using BindMemoryStatusKHR = BindMemoryStatus;
554   struct BindDescriptorSetsInfo;
555   using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo;
556   struct PushConstantsInfo;
557   using PushConstantsInfoKHR = PushConstantsInfo;
558   struct PushDescriptorSetInfo;
559   using PushDescriptorSetInfoKHR = PushDescriptorSetInfo;
560   struct PushDescriptorSetWithTemplateInfo;
561   using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo;
562   struct PhysicalDevicePipelineProtectedAccessFeatures;
563   using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures;
564   struct PhysicalDevicePipelineRobustnessFeatures;
565   using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures;
566   struct PhysicalDevicePipelineRobustnessProperties;
567   using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties;
568   struct PipelineRobustnessCreateInfo;
569   using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo;
570   struct PhysicalDeviceHostImageCopyFeatures;
571   using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures;
572   struct PhysicalDeviceHostImageCopyProperties;
573   using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties;
574   struct MemoryToImageCopy;
575   using MemoryToImageCopyEXT = MemoryToImageCopy;
576   struct ImageToMemoryCopy;
577   using ImageToMemoryCopyEXT = ImageToMemoryCopy;
578   struct CopyMemoryToImageInfo;
579   using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo;
580   struct CopyImageToMemoryInfo;
581   using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;
582   struct CopyImageToImageInfo;
583   using CopyImageToImageInfoEXT = CopyImageToImageInfo;
584   struct HostImageLayoutTransitionInfo;
585   using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo;
586   struct SubresourceHostMemcpySize;
587   using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize;
588   struct HostImageCopyDevicePerformanceQuery;
589   using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery;
590 
591   //=== VK_KHR_surface ===
592   struct SurfaceCapabilitiesKHR;
593   struct SurfaceFormatKHR;
594 
595   //=== VK_KHR_swapchain ===
596   struct SwapchainCreateInfoKHR;
597   struct PresentInfoKHR;
598   struct ImageSwapchainCreateInfoKHR;
599   struct BindImageMemorySwapchainInfoKHR;
600   struct AcquireNextImageInfoKHR;
601   struct DeviceGroupPresentCapabilitiesKHR;
602   struct DeviceGroupPresentInfoKHR;
603   struct DeviceGroupSwapchainCreateInfoKHR;
604 
605   //=== VK_KHR_display ===
606   struct DisplayModeCreateInfoKHR;
607   struct DisplayModeParametersKHR;
608   struct DisplayModePropertiesKHR;
609   struct DisplayPlaneCapabilitiesKHR;
610   struct DisplayPlanePropertiesKHR;
611   struct DisplayPropertiesKHR;
612   struct DisplaySurfaceCreateInfoKHR;
613 
614   //=== VK_KHR_display_swapchain ===
615   struct DisplayPresentInfoKHR;
616 
617 #if defined( VK_USE_PLATFORM_XLIB_KHR )
618   //=== VK_KHR_xlib_surface ===
619   struct XlibSurfaceCreateInfoKHR;
620 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
621 
622 #if defined( VK_USE_PLATFORM_XCB_KHR )
623   //=== VK_KHR_xcb_surface ===
624   struct XcbSurfaceCreateInfoKHR;
625 #endif /*VK_USE_PLATFORM_XCB_KHR*/
626 
627 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
628   //=== VK_KHR_wayland_surface ===
629   struct WaylandSurfaceCreateInfoKHR;
630 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
631 
632 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
633   //=== VK_KHR_android_surface ===
634   struct AndroidSurfaceCreateInfoKHR;
635 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
636 
637 #if defined( VK_USE_PLATFORM_WIN32_KHR )
638   //=== VK_KHR_win32_surface ===
639   struct Win32SurfaceCreateInfoKHR;
640 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
641 
642   //=== VK_EXT_debug_report ===
643   struct DebugReportCallbackCreateInfoEXT;
644 
645   //=== VK_AMD_rasterization_order ===
646   struct PipelineRasterizationStateRasterizationOrderAMD;
647 
648   //=== VK_EXT_debug_marker ===
649   struct DebugMarkerObjectNameInfoEXT;
650   struct DebugMarkerObjectTagInfoEXT;
651   struct DebugMarkerMarkerInfoEXT;
652 
653   //=== VK_KHR_video_queue ===
654   struct QueueFamilyQueryResultStatusPropertiesKHR;
655   struct QueueFamilyVideoPropertiesKHR;
656   struct VideoProfileInfoKHR;
657   struct VideoProfileListInfoKHR;
658   struct VideoCapabilitiesKHR;
659   struct PhysicalDeviceVideoFormatInfoKHR;
660   struct VideoFormatPropertiesKHR;
661   struct VideoPictureResourceInfoKHR;
662   struct VideoReferenceSlotInfoKHR;
663   struct VideoSessionMemoryRequirementsKHR;
664   struct BindVideoSessionMemoryInfoKHR;
665   struct VideoSessionCreateInfoKHR;
666   struct VideoSessionParametersCreateInfoKHR;
667   struct VideoSessionParametersUpdateInfoKHR;
668   struct VideoBeginCodingInfoKHR;
669   struct VideoEndCodingInfoKHR;
670   struct VideoCodingControlInfoKHR;
671 
672   //=== VK_KHR_video_decode_queue ===
673   struct VideoDecodeCapabilitiesKHR;
674   struct VideoDecodeUsageInfoKHR;
675   struct VideoDecodeInfoKHR;
676 
677   //=== VK_NV_dedicated_allocation ===
678   struct DedicatedAllocationImageCreateInfoNV;
679   struct DedicatedAllocationBufferCreateInfoNV;
680   struct DedicatedAllocationMemoryAllocateInfoNV;
681 
682   //=== VK_EXT_transform_feedback ===
683   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
684   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
685   struct PipelineRasterizationStateStreamCreateInfoEXT;
686 
687   //=== VK_NVX_binary_import ===
688   struct CuModuleCreateInfoNVX;
689   struct CuFunctionCreateInfoNVX;
690   struct CuLaunchInfoNVX;
691 
692   //=== VK_NVX_image_view_handle ===
693   struct ImageViewHandleInfoNVX;
694   struct ImageViewAddressPropertiesNVX;
695 
696   //=== VK_KHR_video_encode_h264 ===
697   struct VideoEncodeH264CapabilitiesKHR;
698   struct VideoEncodeH264QualityLevelPropertiesKHR;
699   struct VideoEncodeH264SessionCreateInfoKHR;
700   struct VideoEncodeH264SessionParametersCreateInfoKHR;
701   struct VideoEncodeH264SessionParametersAddInfoKHR;
702   struct VideoEncodeH264SessionParametersGetInfoKHR;
703   struct VideoEncodeH264SessionParametersFeedbackInfoKHR;
704   struct VideoEncodeH264PictureInfoKHR;
705   struct VideoEncodeH264DpbSlotInfoKHR;
706   struct VideoEncodeH264NaluSliceInfoKHR;
707   struct VideoEncodeH264ProfileInfoKHR;
708   struct VideoEncodeH264RateControlInfoKHR;
709   struct VideoEncodeH264RateControlLayerInfoKHR;
710   struct VideoEncodeH264QpKHR;
711   struct VideoEncodeH264FrameSizeKHR;
712   struct VideoEncodeH264GopRemainingFrameInfoKHR;
713 
714   //=== VK_KHR_video_encode_h265 ===
715   struct VideoEncodeH265CapabilitiesKHR;
716   struct VideoEncodeH265SessionCreateInfoKHR;
717   struct VideoEncodeH265QualityLevelPropertiesKHR;
718   struct VideoEncodeH265SessionParametersCreateInfoKHR;
719   struct VideoEncodeH265SessionParametersAddInfoKHR;
720   struct VideoEncodeH265SessionParametersGetInfoKHR;
721   struct VideoEncodeH265SessionParametersFeedbackInfoKHR;
722   struct VideoEncodeH265PictureInfoKHR;
723   struct VideoEncodeH265DpbSlotInfoKHR;
724   struct VideoEncodeH265NaluSliceSegmentInfoKHR;
725   struct VideoEncodeH265ProfileInfoKHR;
726   struct VideoEncodeH265RateControlInfoKHR;
727   struct VideoEncodeH265RateControlLayerInfoKHR;
728   struct VideoEncodeH265QpKHR;
729   struct VideoEncodeH265FrameSizeKHR;
730   struct VideoEncodeH265GopRemainingFrameInfoKHR;
731 
732   //=== VK_KHR_video_decode_h264 ===
733   struct VideoDecodeH264ProfileInfoKHR;
734   struct VideoDecodeH264CapabilitiesKHR;
735   struct VideoDecodeH264SessionParametersCreateInfoKHR;
736   struct VideoDecodeH264SessionParametersAddInfoKHR;
737   struct VideoDecodeH264PictureInfoKHR;
738   struct VideoDecodeH264DpbSlotInfoKHR;
739 
740   //=== VK_AMD_texture_gather_bias_lod ===
741   struct TextureLODGatherFormatPropertiesAMD;
742 
743   //=== VK_AMD_shader_info ===
744   struct ShaderResourceUsageAMD;
745   struct ShaderStatisticsInfoAMD;
746 
747   //=== VK_KHR_dynamic_rendering ===
748   struct RenderingFragmentShadingRateAttachmentInfoKHR;
749   struct RenderingFragmentDensityMapAttachmentInfoEXT;
750   struct AttachmentSampleCountInfoAMD;
751   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
752   struct MultiviewPerViewAttributesInfoNVX;
753 
754 #if defined( VK_USE_PLATFORM_GGP )
755   //=== VK_GGP_stream_descriptor_surface ===
756   struct StreamDescriptorSurfaceCreateInfoGGP;
757 #endif /*VK_USE_PLATFORM_GGP*/
758 
759   //=== VK_NV_corner_sampled_image ===
760   struct PhysicalDeviceCornerSampledImageFeaturesNV;
761 
762   //=== VK_NV_external_memory_capabilities ===
763   struct ExternalImageFormatPropertiesNV;
764 
765   //=== VK_NV_external_memory ===
766   struct ExternalMemoryImageCreateInfoNV;
767   struct ExportMemoryAllocateInfoNV;
768 
769 #if defined( VK_USE_PLATFORM_WIN32_KHR )
770   //=== VK_NV_external_memory_win32 ===
771   struct ImportMemoryWin32HandleInfoNV;
772   struct ExportMemoryWin32HandleInfoNV;
773 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
774 
775 #if defined( VK_USE_PLATFORM_WIN32_KHR )
776   //=== VK_NV_win32_keyed_mutex ===
777   struct Win32KeyedMutexAcquireReleaseInfoNV;
778 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
779 
780   //=== VK_EXT_validation_flags ===
781   struct ValidationFlagsEXT;
782 
783 #if defined( VK_USE_PLATFORM_VI_NN )
784   //=== VK_NN_vi_surface ===
785   struct ViSurfaceCreateInfoNN;
786 #endif /*VK_USE_PLATFORM_VI_NN*/
787 
788   //=== VK_EXT_astc_decode_mode ===
789   struct ImageViewASTCDecodeModeEXT;
790   struct PhysicalDeviceASTCDecodeFeaturesEXT;
791 
792 #if defined( VK_USE_PLATFORM_WIN32_KHR )
793   //=== VK_KHR_external_memory_win32 ===
794   struct ImportMemoryWin32HandleInfoKHR;
795   struct ExportMemoryWin32HandleInfoKHR;
796   struct MemoryWin32HandlePropertiesKHR;
797   struct MemoryGetWin32HandleInfoKHR;
798 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
799 
800   //=== VK_KHR_external_memory_fd ===
801   struct ImportMemoryFdInfoKHR;
802   struct MemoryFdPropertiesKHR;
803   struct MemoryGetFdInfoKHR;
804 
805 #if defined( VK_USE_PLATFORM_WIN32_KHR )
806   //=== VK_KHR_win32_keyed_mutex ===
807   struct Win32KeyedMutexAcquireReleaseInfoKHR;
808 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
809 
810 #if defined( VK_USE_PLATFORM_WIN32_KHR )
811   //=== VK_KHR_external_semaphore_win32 ===
812   struct ImportSemaphoreWin32HandleInfoKHR;
813   struct ExportSemaphoreWin32HandleInfoKHR;
814   struct D3D12FenceSubmitInfoKHR;
815   struct SemaphoreGetWin32HandleInfoKHR;
816 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
817 
818   //=== VK_KHR_external_semaphore_fd ===
819   struct ImportSemaphoreFdInfoKHR;
820   struct SemaphoreGetFdInfoKHR;
821 
822   //=== VK_EXT_conditional_rendering ===
823   struct ConditionalRenderingBeginInfoEXT;
824   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
825   struct CommandBufferInheritanceConditionalRenderingInfoEXT;
826 
827   //=== VK_KHR_incremental_present ===
828   struct PresentRegionsKHR;
829   struct PresentRegionKHR;
830   struct RectLayerKHR;
831 
832   //=== VK_NV_clip_space_w_scaling ===
833   struct ViewportWScalingNV;
834   struct PipelineViewportWScalingStateCreateInfoNV;
835 
836   //=== VK_EXT_display_surface_counter ===
837   struct SurfaceCapabilities2EXT;
838 
839   //=== VK_EXT_display_control ===
840   struct DisplayPowerInfoEXT;
841   struct DeviceEventInfoEXT;
842   struct DisplayEventInfoEXT;
843   struct SwapchainCounterCreateInfoEXT;
844 
845   //=== VK_GOOGLE_display_timing ===
846   struct RefreshCycleDurationGOOGLE;
847   struct PastPresentationTimingGOOGLE;
848   struct PresentTimesInfoGOOGLE;
849   struct PresentTimeGOOGLE;
850 
851   //=== VK_NVX_multiview_per_view_attributes ===
852   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
853 
854   //=== VK_NV_viewport_swizzle ===
855   struct ViewportSwizzleNV;
856   struct PipelineViewportSwizzleStateCreateInfoNV;
857 
858   //=== VK_EXT_discard_rectangles ===
859   struct PhysicalDeviceDiscardRectanglePropertiesEXT;
860   struct PipelineDiscardRectangleStateCreateInfoEXT;
861 
862   //=== VK_EXT_conservative_rasterization ===
863   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
864   struct PipelineRasterizationConservativeStateCreateInfoEXT;
865 
866   //=== VK_EXT_depth_clip_enable ===
867   struct PhysicalDeviceDepthClipEnableFeaturesEXT;
868   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
869 
870   //=== VK_EXT_hdr_metadata ===
871   struct HdrMetadataEXT;
872   struct XYColorEXT;
873 
874   //=== VK_IMG_relaxed_line_rasterization ===
875   struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
876 
877   //=== VK_KHR_shared_presentable_image ===
878   struct SharedPresentSurfaceCapabilitiesKHR;
879 
880 #if defined( VK_USE_PLATFORM_WIN32_KHR )
881   //=== VK_KHR_external_fence_win32 ===
882   struct ImportFenceWin32HandleInfoKHR;
883   struct ExportFenceWin32HandleInfoKHR;
884   struct FenceGetWin32HandleInfoKHR;
885 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
886 
887   //=== VK_KHR_external_fence_fd ===
888   struct ImportFenceFdInfoKHR;
889   struct FenceGetFdInfoKHR;
890 
891   //=== VK_KHR_performance_query ===
892   struct PhysicalDevicePerformanceQueryFeaturesKHR;
893   struct PhysicalDevicePerformanceQueryPropertiesKHR;
894   struct PerformanceCounterKHR;
895   struct PerformanceCounterDescriptionKHR;
896   struct QueryPoolPerformanceCreateInfoKHR;
897   union PerformanceCounterResultKHR;
898   struct AcquireProfilingLockInfoKHR;
899   struct PerformanceQuerySubmitInfoKHR;
900 
901   //=== VK_KHR_get_surface_capabilities2 ===
902   struct PhysicalDeviceSurfaceInfo2KHR;
903   struct SurfaceCapabilities2KHR;
904   struct SurfaceFormat2KHR;
905 
906   //=== VK_KHR_get_display_properties2 ===
907   struct DisplayProperties2KHR;
908   struct DisplayPlaneProperties2KHR;
909   struct DisplayModeProperties2KHR;
910   struct DisplayPlaneInfo2KHR;
911   struct DisplayPlaneCapabilities2KHR;
912 
913 #if defined( VK_USE_PLATFORM_IOS_MVK )
914   //=== VK_MVK_ios_surface ===
915   struct IOSSurfaceCreateInfoMVK;
916 #endif /*VK_USE_PLATFORM_IOS_MVK*/
917 
918 #if defined( VK_USE_PLATFORM_MACOS_MVK )
919   //=== VK_MVK_macos_surface ===
920   struct MacOSSurfaceCreateInfoMVK;
921 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
922 
923   //=== VK_EXT_debug_utils ===
924   struct DebugUtilsLabelEXT;
925   struct DebugUtilsMessengerCallbackDataEXT;
926   struct DebugUtilsMessengerCreateInfoEXT;
927   struct DebugUtilsObjectNameInfoEXT;
928   struct DebugUtilsObjectTagInfoEXT;
929 
930 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
931   //=== VK_ANDROID_external_memory_android_hardware_buffer ===
932   struct AndroidHardwareBufferUsageANDROID;
933   struct AndroidHardwareBufferPropertiesANDROID;
934   struct AndroidHardwareBufferFormatPropertiesANDROID;
935   struct ImportAndroidHardwareBufferInfoANDROID;
936   struct MemoryGetAndroidHardwareBufferInfoANDROID;
937   struct ExternalFormatANDROID;
938   struct AndroidHardwareBufferFormatProperties2ANDROID;
939 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
940 
941 #if defined( VK_ENABLE_BETA_EXTENSIONS )
942   //=== VK_AMDX_shader_enqueue ===
943   struct PhysicalDeviceShaderEnqueueFeaturesAMDX;
944   struct PhysicalDeviceShaderEnqueuePropertiesAMDX;
945   struct ExecutionGraphPipelineScratchSizeAMDX;
946   struct ExecutionGraphPipelineCreateInfoAMDX;
947   struct DispatchGraphInfoAMDX;
948   struct DispatchGraphCountInfoAMDX;
949   struct PipelineShaderStageNodeCreateInfoAMDX;
950   union DeviceOrHostAddressConstAMDX;
951 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
952 
953   //=== VK_EXT_sample_locations ===
954   struct SampleLocationEXT;
955   struct SampleLocationsInfoEXT;
956   struct AttachmentSampleLocationsEXT;
957   struct SubpassSampleLocationsEXT;
958   struct RenderPassSampleLocationsBeginInfoEXT;
959   struct PipelineSampleLocationsStateCreateInfoEXT;
960   struct PhysicalDeviceSampleLocationsPropertiesEXT;
961   struct MultisamplePropertiesEXT;
962 
963   //=== VK_EXT_blend_operation_advanced ===
964   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
965   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
966   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
967 
968   //=== VK_NV_fragment_coverage_to_color ===
969   struct PipelineCoverageToColorStateCreateInfoNV;
970 
971   //=== VK_KHR_acceleration_structure ===
972   union DeviceOrHostAddressKHR;
973   union DeviceOrHostAddressConstKHR;
974   struct AccelerationStructureBuildRangeInfoKHR;
975   struct AabbPositionsKHR;
976   using AabbPositionsNV = AabbPositionsKHR;
977   struct AccelerationStructureGeometryTrianglesDataKHR;
978   struct TransformMatrixKHR;
979   using TransformMatrixNV = TransformMatrixKHR;
980   struct AccelerationStructureBuildGeometryInfoKHR;
981   struct AccelerationStructureGeometryAabbsDataKHR;
982   struct AccelerationStructureInstanceKHR;
983   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
984   struct AccelerationStructureGeometryInstancesDataKHR;
985   union AccelerationStructureGeometryDataKHR;
986   struct AccelerationStructureGeometryKHR;
987   struct AccelerationStructureCreateInfoKHR;
988   struct WriteDescriptorSetAccelerationStructureKHR;
989   struct PhysicalDeviceAccelerationStructureFeaturesKHR;
990   struct PhysicalDeviceAccelerationStructurePropertiesKHR;
991   struct AccelerationStructureDeviceAddressInfoKHR;
992   struct AccelerationStructureVersionInfoKHR;
993   struct CopyAccelerationStructureToMemoryInfoKHR;
994   struct CopyMemoryToAccelerationStructureInfoKHR;
995   struct CopyAccelerationStructureInfoKHR;
996   struct AccelerationStructureBuildSizesInfoKHR;
997 
998   //=== VK_KHR_ray_tracing_pipeline ===
999   struct RayTracingShaderGroupCreateInfoKHR;
1000   struct RayTracingPipelineCreateInfoKHR;
1001   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
1002   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
1003   struct StridedDeviceAddressRegionKHR;
1004   struct TraceRaysIndirectCommandKHR;
1005   struct RayTracingPipelineInterfaceCreateInfoKHR;
1006 
1007   //=== VK_KHR_ray_query ===
1008   struct PhysicalDeviceRayQueryFeaturesKHR;
1009 
1010   //=== VK_NV_framebuffer_mixed_samples ===
1011   struct PipelineCoverageModulationStateCreateInfoNV;
1012 
1013   //=== VK_NV_shader_sm_builtins ===
1014   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
1015   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
1016 
1017   //=== VK_EXT_image_drm_format_modifier ===
1018   struct DrmFormatModifierPropertiesListEXT;
1019   struct DrmFormatModifierPropertiesEXT;
1020   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
1021   struct ImageDrmFormatModifierListCreateInfoEXT;
1022   struct ImageDrmFormatModifierExplicitCreateInfoEXT;
1023   struct ImageDrmFormatModifierPropertiesEXT;
1024   struct DrmFormatModifierPropertiesList2EXT;
1025   struct DrmFormatModifierProperties2EXT;
1026 
1027   //=== VK_EXT_validation_cache ===
1028   struct ValidationCacheCreateInfoEXT;
1029   struct ShaderModuleValidationCacheCreateInfoEXT;
1030 
1031 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1032   //=== VK_KHR_portability_subset ===
1033   struct PhysicalDevicePortabilitySubsetFeaturesKHR;
1034   struct PhysicalDevicePortabilitySubsetPropertiesKHR;
1035 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1036 
1037   //=== VK_NV_shading_rate_image ===
1038   struct ShadingRatePaletteNV;
1039   struct PipelineViewportShadingRateImageStateCreateInfoNV;
1040   struct PhysicalDeviceShadingRateImageFeaturesNV;
1041   struct PhysicalDeviceShadingRateImagePropertiesNV;
1042   struct CoarseSampleLocationNV;
1043   struct CoarseSampleOrderCustomNV;
1044   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
1045 
1046   //=== VK_NV_ray_tracing ===
1047   struct RayTracingShaderGroupCreateInfoNV;
1048   struct RayTracingPipelineCreateInfoNV;
1049   struct GeometryTrianglesNV;
1050   struct GeometryAABBNV;
1051   struct GeometryDataNV;
1052   struct GeometryNV;
1053   struct AccelerationStructureInfoNV;
1054   struct AccelerationStructureCreateInfoNV;
1055   struct BindAccelerationStructureMemoryInfoNV;
1056   struct WriteDescriptorSetAccelerationStructureNV;
1057   struct AccelerationStructureMemoryRequirementsInfoNV;
1058   struct PhysicalDeviceRayTracingPropertiesNV;
1059 
1060   //=== VK_NV_representative_fragment_test ===
1061   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
1062   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
1063 
1064   //=== VK_EXT_filter_cubic ===
1065   struct PhysicalDeviceImageViewImageFormatInfoEXT;
1066   struct FilterCubicImageViewImageFormatPropertiesEXT;
1067 
1068   //=== VK_EXT_external_memory_host ===
1069   struct ImportMemoryHostPointerInfoEXT;
1070   struct MemoryHostPointerPropertiesEXT;
1071   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
1072 
1073   //=== VK_KHR_shader_clock ===
1074   struct PhysicalDeviceShaderClockFeaturesKHR;
1075 
1076   //=== VK_AMD_pipeline_compiler_control ===
1077   struct PipelineCompilerControlCreateInfoAMD;
1078 
1079   //=== VK_AMD_shader_core_properties ===
1080   struct PhysicalDeviceShaderCorePropertiesAMD;
1081 
1082   //=== VK_KHR_video_decode_h265 ===
1083   struct VideoDecodeH265ProfileInfoKHR;
1084   struct VideoDecodeH265CapabilitiesKHR;
1085   struct VideoDecodeH265SessionParametersCreateInfoKHR;
1086   struct VideoDecodeH265SessionParametersAddInfoKHR;
1087   struct VideoDecodeH265PictureInfoKHR;
1088   struct VideoDecodeH265DpbSlotInfoKHR;
1089 
1090   //=== VK_AMD_memory_overallocation_behavior ===
1091   struct DeviceMemoryOverallocationCreateInfoAMD;
1092 
1093   //=== VK_EXT_vertex_attribute_divisor ===
1094   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
1095 
1096 #if defined( VK_USE_PLATFORM_GGP )
1097   //=== VK_GGP_frame_token ===
1098   struct PresentFrameTokenGGP;
1099 #endif /*VK_USE_PLATFORM_GGP*/
1100 
1101   //=== VK_NV_compute_shader_derivatives ===
1102   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
1103 
1104   //=== VK_NV_mesh_shader ===
1105   struct PhysicalDeviceMeshShaderFeaturesNV;
1106   struct PhysicalDeviceMeshShaderPropertiesNV;
1107   struct DrawMeshTasksIndirectCommandNV;
1108 
1109   //=== VK_NV_shader_image_footprint ===
1110   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
1111 
1112   //=== VK_NV_scissor_exclusive ===
1113   struct PipelineViewportExclusiveScissorStateCreateInfoNV;
1114   struct PhysicalDeviceExclusiveScissorFeaturesNV;
1115 
1116   //=== VK_NV_device_diagnostic_checkpoints ===
1117   struct QueueFamilyCheckpointPropertiesNV;
1118   struct CheckpointDataNV;
1119 
1120   //=== VK_INTEL_shader_integer_functions2 ===
1121   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
1122 
1123   //=== VK_INTEL_performance_query ===
1124   union PerformanceValueDataINTEL;
1125   struct PerformanceValueINTEL;
1126   struct InitializePerformanceApiInfoINTEL;
1127   struct QueryPoolPerformanceQueryCreateInfoINTEL;
1128   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
1129   struct PerformanceMarkerInfoINTEL;
1130   struct PerformanceStreamMarkerInfoINTEL;
1131   struct PerformanceOverrideInfoINTEL;
1132   struct PerformanceConfigurationAcquireInfoINTEL;
1133 
1134   //=== VK_EXT_pci_bus_info ===
1135   struct PhysicalDevicePCIBusInfoPropertiesEXT;
1136 
1137   //=== VK_AMD_display_native_hdr ===
1138   struct DisplayNativeHdrSurfaceCapabilitiesAMD;
1139   struct SwapchainDisplayNativeHdrCreateInfoAMD;
1140 
1141 #if defined( VK_USE_PLATFORM_FUCHSIA )
1142   //=== VK_FUCHSIA_imagepipe_surface ===
1143   struct ImagePipeSurfaceCreateInfoFUCHSIA;
1144 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1145 
1146 #if defined( VK_USE_PLATFORM_METAL_EXT )
1147   //=== VK_EXT_metal_surface ===
1148   struct MetalSurfaceCreateInfoEXT;
1149 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1150 
1151   //=== VK_EXT_fragment_density_map ===
1152   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
1153   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
1154   struct RenderPassFragmentDensityMapCreateInfoEXT;
1155 
1156   //=== VK_KHR_fragment_shading_rate ===
1157   struct FragmentShadingRateAttachmentInfoKHR;
1158   struct PipelineFragmentShadingRateStateCreateInfoKHR;
1159   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
1160   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
1161   struct PhysicalDeviceFragmentShadingRateKHR;
1162 
1163   //=== VK_AMD_shader_core_properties2 ===
1164   struct PhysicalDeviceShaderCoreProperties2AMD;
1165 
1166   //=== VK_AMD_device_coherent_memory ===
1167   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
1168 
1169   //=== VK_EXT_shader_image_atomic_int64 ===
1170   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
1171 
1172   //=== VK_KHR_shader_quad_control ===
1173   struct PhysicalDeviceShaderQuadControlFeaturesKHR;
1174 
1175   //=== VK_EXT_memory_budget ===
1176   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
1177 
1178   //=== VK_EXT_memory_priority ===
1179   struct PhysicalDeviceMemoryPriorityFeaturesEXT;
1180   struct MemoryPriorityAllocateInfoEXT;
1181 
1182   //=== VK_KHR_surface_protected_capabilities ===
1183   struct SurfaceProtectedCapabilitiesKHR;
1184 
1185   //=== VK_NV_dedicated_allocation_image_aliasing ===
1186   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
1187 
1188   //=== VK_EXT_buffer_device_address ===
1189   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1190   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1191   struct BufferDeviceAddressCreateInfoEXT;
1192 
1193   //=== VK_EXT_validation_features ===
1194   struct ValidationFeaturesEXT;
1195 
1196   //=== VK_KHR_present_wait ===
1197   struct PhysicalDevicePresentWaitFeaturesKHR;
1198 
1199   //=== VK_NV_cooperative_matrix ===
1200   struct CooperativeMatrixPropertiesNV;
1201   struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1202   struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1203 
1204   //=== VK_NV_coverage_reduction_mode ===
1205   struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1206   struct PipelineCoverageReductionStateCreateInfoNV;
1207   struct FramebufferMixedSamplesCombinationNV;
1208 
1209   //=== VK_EXT_fragment_shader_interlock ===
1210   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1211 
1212   //=== VK_EXT_ycbcr_image_arrays ===
1213   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1214 
1215   //=== VK_EXT_provoking_vertex ===
1216   struct PhysicalDeviceProvokingVertexFeaturesEXT;
1217   struct PhysicalDeviceProvokingVertexPropertiesEXT;
1218   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1219 
1220 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1221   //=== VK_EXT_full_screen_exclusive ===
1222   struct SurfaceFullScreenExclusiveInfoEXT;
1223   struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1224   struct SurfaceFullScreenExclusiveWin32InfoEXT;
1225 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1226 
1227   //=== VK_EXT_headless_surface ===
1228   struct HeadlessSurfaceCreateInfoEXT;
1229 
1230   //=== VK_EXT_shader_atomic_float ===
1231   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1232 
1233   //=== VK_EXT_extended_dynamic_state ===
1234   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1235 
1236   //=== VK_KHR_pipeline_executable_properties ===
1237   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1238   struct PipelineInfoKHR;
1239   using PipelineInfoEXT = PipelineInfoKHR;
1240   struct PipelineExecutablePropertiesKHR;
1241   struct PipelineExecutableInfoKHR;
1242   union PipelineExecutableStatisticValueKHR;
1243   struct PipelineExecutableStatisticKHR;
1244   struct PipelineExecutableInternalRepresentationKHR;
1245 
1246   //=== VK_EXT_map_memory_placed ===
1247   struct PhysicalDeviceMapMemoryPlacedFeaturesEXT;
1248   struct PhysicalDeviceMapMemoryPlacedPropertiesEXT;
1249   struct MemoryMapPlacedInfoEXT;
1250 
1251   //=== VK_EXT_shader_atomic_float2 ===
1252   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1253 
1254   //=== VK_EXT_surface_maintenance1 ===
1255   struct SurfacePresentModeEXT;
1256   struct SurfacePresentScalingCapabilitiesEXT;
1257   struct SurfacePresentModeCompatibilityEXT;
1258 
1259   //=== VK_EXT_swapchain_maintenance1 ===
1260   struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
1261   struct SwapchainPresentFenceInfoEXT;
1262   struct SwapchainPresentModesCreateInfoEXT;
1263   struct SwapchainPresentModeInfoEXT;
1264   struct SwapchainPresentScalingCreateInfoEXT;
1265   struct ReleaseSwapchainImagesInfoEXT;
1266 
1267   //=== VK_NV_device_generated_commands ===
1268   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1269   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1270   struct GraphicsShaderGroupCreateInfoNV;
1271   struct GraphicsPipelineShaderGroupsCreateInfoNV;
1272   struct BindShaderGroupIndirectCommandNV;
1273   struct BindIndexBufferIndirectCommandNV;
1274   struct BindVertexBufferIndirectCommandNV;
1275   struct SetStateFlagsIndirectCommandNV;
1276   struct IndirectCommandsStreamNV;
1277   struct IndirectCommandsLayoutTokenNV;
1278   struct IndirectCommandsLayoutCreateInfoNV;
1279   struct GeneratedCommandsInfoNV;
1280   struct GeneratedCommandsMemoryRequirementsInfoNV;
1281 
1282   //=== VK_NV_inherited_viewport_scissor ===
1283   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1284   struct CommandBufferInheritanceViewportScissorInfoNV;
1285 
1286   //=== VK_EXT_texel_buffer_alignment ===
1287   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1288 
1289   //=== VK_QCOM_render_pass_transform ===
1290   struct RenderPassTransformBeginInfoQCOM;
1291   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1292 
1293   //=== VK_EXT_depth_bias_control ===
1294   struct PhysicalDeviceDepthBiasControlFeaturesEXT;
1295   struct DepthBiasInfoEXT;
1296   struct DepthBiasRepresentationInfoEXT;
1297 
1298   //=== VK_EXT_device_memory_report ===
1299   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1300   struct DeviceDeviceMemoryReportCreateInfoEXT;
1301   struct DeviceMemoryReportCallbackDataEXT;
1302 
1303   //=== VK_EXT_robustness2 ===
1304   struct PhysicalDeviceRobustness2FeaturesEXT;
1305   struct PhysicalDeviceRobustness2PropertiesEXT;
1306 
1307   //=== VK_EXT_custom_border_color ===
1308   struct SamplerCustomBorderColorCreateInfoEXT;
1309   struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1310   struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1311 
1312   //=== VK_KHR_pipeline_library ===
1313   struct PipelineLibraryCreateInfoKHR;
1314 
1315   //=== VK_NV_present_barrier ===
1316   struct PhysicalDevicePresentBarrierFeaturesNV;
1317   struct SurfaceCapabilitiesPresentBarrierNV;
1318   struct SwapchainPresentBarrierCreateInfoNV;
1319 
1320   //=== VK_KHR_present_id ===
1321   struct PresentIdKHR;
1322   struct PhysicalDevicePresentIdFeaturesKHR;
1323 
1324   //=== VK_KHR_video_encode_queue ===
1325   struct VideoEncodeInfoKHR;
1326   struct VideoEncodeCapabilitiesKHR;
1327   struct QueryPoolVideoEncodeFeedbackCreateInfoKHR;
1328   struct VideoEncodeUsageInfoKHR;
1329   struct VideoEncodeRateControlInfoKHR;
1330   struct VideoEncodeRateControlLayerInfoKHR;
1331   struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
1332   struct VideoEncodeQualityLevelPropertiesKHR;
1333   struct VideoEncodeQualityLevelInfoKHR;
1334   struct VideoEncodeSessionParametersGetInfoKHR;
1335   struct VideoEncodeSessionParametersFeedbackInfoKHR;
1336 
1337   //=== VK_NV_device_diagnostics_config ===
1338   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1339   struct DeviceDiagnosticsConfigCreateInfoNV;
1340 
1341 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1342   //=== VK_NV_cuda_kernel_launch ===
1343   struct CudaModuleCreateInfoNV;
1344   struct CudaFunctionCreateInfoNV;
1345   struct CudaLaunchInfoNV;
1346   struct PhysicalDeviceCudaKernelLaunchFeaturesNV;
1347   struct PhysicalDeviceCudaKernelLaunchPropertiesNV;
1348 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1349 
1350   //=== VK_NV_low_latency ===
1351   struct QueryLowLatencySupportNV;
1352 
1353 #if defined( VK_USE_PLATFORM_METAL_EXT )
1354   //=== VK_EXT_metal_objects ===
1355   struct ExportMetalObjectCreateInfoEXT;
1356   struct ExportMetalObjectsInfoEXT;
1357   struct ExportMetalDeviceInfoEXT;
1358   struct ExportMetalCommandQueueInfoEXT;
1359   struct ExportMetalBufferInfoEXT;
1360   struct ImportMetalBufferInfoEXT;
1361   struct ExportMetalTextureInfoEXT;
1362   struct ImportMetalTextureInfoEXT;
1363   struct ExportMetalIOSurfaceInfoEXT;
1364   struct ImportMetalIOSurfaceInfoEXT;
1365   struct ExportMetalSharedEventInfoEXT;
1366   struct ImportMetalSharedEventInfoEXT;
1367 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1368 
1369   //=== VK_KHR_synchronization2 ===
1370   struct QueueFamilyCheckpointProperties2NV;
1371   struct CheckpointData2NV;
1372 
1373   //=== VK_EXT_descriptor_buffer ===
1374   struct PhysicalDeviceDescriptorBufferPropertiesEXT;
1375   struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
1376   struct PhysicalDeviceDescriptorBufferFeaturesEXT;
1377   struct DescriptorAddressInfoEXT;
1378   struct DescriptorBufferBindingInfoEXT;
1379   struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;
1380   union DescriptorDataEXT;
1381   struct DescriptorGetInfoEXT;
1382   struct BufferCaptureDescriptorDataInfoEXT;
1383   struct ImageCaptureDescriptorDataInfoEXT;
1384   struct ImageViewCaptureDescriptorDataInfoEXT;
1385   struct SamplerCaptureDescriptorDataInfoEXT;
1386   struct OpaqueCaptureDescriptorDataCreateInfoEXT;
1387   struct AccelerationStructureCaptureDescriptorDataInfoEXT;
1388 
1389   //=== VK_EXT_graphics_pipeline_library ===
1390   struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
1391   struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
1392   struct GraphicsPipelineLibraryCreateInfoEXT;
1393 
1394   //=== VK_AMD_shader_early_and_late_fragment_tests ===
1395   struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
1396 
1397   //=== VK_KHR_fragment_shader_barycentric ===
1398   struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1399   using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1400   struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
1401 
1402   //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1403   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1404 
1405   //=== VK_NV_fragment_shading_rate_enums ===
1406   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1407   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1408   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1409 
1410   //=== VK_NV_ray_tracing_motion_blur ===
1411   struct AccelerationStructureGeometryMotionTrianglesDataNV;
1412   struct AccelerationStructureMotionInfoNV;
1413   struct AccelerationStructureMotionInstanceNV;
1414   union AccelerationStructureMotionInstanceDataNV;
1415   struct AccelerationStructureMatrixMotionInstanceNV;
1416   struct AccelerationStructureSRTMotionInstanceNV;
1417   struct SRTDataNV;
1418   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1419 
1420   //=== VK_EXT_mesh_shader ===
1421   struct PhysicalDeviceMeshShaderFeaturesEXT;
1422   struct PhysicalDeviceMeshShaderPropertiesEXT;
1423   struct DrawMeshTasksIndirectCommandEXT;
1424 
1425   //=== VK_EXT_ycbcr_2plane_444_formats ===
1426   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1427 
1428   //=== VK_EXT_fragment_density_map2 ===
1429   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1430   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1431 
1432   //=== VK_QCOM_rotated_copy_commands ===
1433   struct CopyCommandTransformInfoQCOM;
1434 
1435   //=== VK_KHR_workgroup_memory_explicit_layout ===
1436   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1437 
1438   //=== VK_EXT_image_compression_control ===
1439   struct PhysicalDeviceImageCompressionControlFeaturesEXT;
1440   struct ImageCompressionControlEXT;
1441   struct ImageCompressionPropertiesEXT;
1442 
1443   //=== VK_EXT_attachment_feedback_loop_layout ===
1444   struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
1445 
1446   //=== VK_EXT_4444_formats ===
1447   struct PhysicalDevice4444FormatsFeaturesEXT;
1448 
1449   //=== VK_EXT_device_fault ===
1450   struct PhysicalDeviceFaultFeaturesEXT;
1451   struct DeviceFaultCountsEXT;
1452   struct DeviceFaultInfoEXT;
1453   struct DeviceFaultAddressInfoEXT;
1454   struct DeviceFaultVendorInfoEXT;
1455   struct DeviceFaultVendorBinaryHeaderVersionOneEXT;
1456 
1457   //=== VK_EXT_rgba10x6_formats ===
1458   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1459 
1460 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1461   //=== VK_EXT_directfb_surface ===
1462   struct DirectFBSurfaceCreateInfoEXT;
1463 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1464 
1465   //=== VK_EXT_vertex_input_dynamic_state ===
1466   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1467   struct VertexInputBindingDescription2EXT;
1468   struct VertexInputAttributeDescription2EXT;
1469 
1470   //=== VK_EXT_physical_device_drm ===
1471   struct PhysicalDeviceDrmPropertiesEXT;
1472 
1473   //=== VK_EXT_device_address_binding_report ===
1474   struct PhysicalDeviceAddressBindingReportFeaturesEXT;
1475   struct DeviceAddressBindingCallbackDataEXT;
1476 
1477   //=== VK_EXT_depth_clip_control ===
1478   struct PhysicalDeviceDepthClipControlFeaturesEXT;
1479   struct PipelineViewportDepthClipControlCreateInfoEXT;
1480 
1481   //=== VK_EXT_primitive_topology_list_restart ===
1482   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1483 
1484 #if defined( VK_USE_PLATFORM_FUCHSIA )
1485   //=== VK_FUCHSIA_external_memory ===
1486   struct ImportMemoryZirconHandleInfoFUCHSIA;
1487   struct MemoryZirconHandlePropertiesFUCHSIA;
1488   struct MemoryGetZirconHandleInfoFUCHSIA;
1489 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1490 
1491 #if defined( VK_USE_PLATFORM_FUCHSIA )
1492   //=== VK_FUCHSIA_external_semaphore ===
1493   struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1494   struct SemaphoreGetZirconHandleInfoFUCHSIA;
1495 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1496 
1497 #if defined( VK_USE_PLATFORM_FUCHSIA )
1498   //=== VK_FUCHSIA_buffer_collection ===
1499   struct BufferCollectionCreateInfoFUCHSIA;
1500   struct ImportMemoryBufferCollectionFUCHSIA;
1501   struct BufferCollectionImageCreateInfoFUCHSIA;
1502   struct BufferConstraintsInfoFUCHSIA;
1503   struct BufferCollectionBufferCreateInfoFUCHSIA;
1504   struct BufferCollectionPropertiesFUCHSIA;
1505   struct SysmemColorSpaceFUCHSIA;
1506   struct ImageConstraintsInfoFUCHSIA;
1507   struct ImageFormatConstraintsInfoFUCHSIA;
1508   struct BufferCollectionConstraintsInfoFUCHSIA;
1509 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1510 
1511   //=== VK_HUAWEI_subpass_shading ===
1512   struct SubpassShadingPipelineCreateInfoHUAWEI;
1513   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1514   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1515 
1516   //=== VK_HUAWEI_invocation_mask ===
1517   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1518 
1519   //=== VK_NV_external_memory_rdma ===
1520   struct MemoryGetRemoteAddressInfoNV;
1521   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1522 
1523   //=== VK_EXT_pipeline_properties ===
1524   struct PipelinePropertiesIdentifierEXT;
1525   struct PhysicalDevicePipelinePropertiesFeaturesEXT;
1526 
1527   //=== VK_EXT_frame_boundary ===
1528   struct PhysicalDeviceFrameBoundaryFeaturesEXT;
1529   struct FrameBoundaryEXT;
1530 
1531   //=== VK_EXT_multisampled_render_to_single_sampled ===
1532   struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
1533   struct SubpassResolvePerformanceQueryEXT;
1534   struct MultisampledRenderToSingleSampledInfoEXT;
1535 
1536   //=== VK_EXT_extended_dynamic_state2 ===
1537   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1538 
1539 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1540   //=== VK_QNX_screen_surface ===
1541   struct ScreenSurfaceCreateInfoQNX;
1542 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1543 
1544   //=== VK_EXT_color_write_enable ===
1545   struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1546   struct PipelineColorWriteCreateInfoEXT;
1547 
1548   //=== VK_EXT_primitives_generated_query ===
1549   struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
1550 
1551   //=== VK_KHR_ray_tracing_maintenance1 ===
1552   struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
1553   struct TraceRaysIndirectCommand2KHR;
1554 
1555   //=== VK_EXT_image_view_min_lod ===
1556   struct PhysicalDeviceImageViewMinLodFeaturesEXT;
1557   struct ImageViewMinLodCreateInfoEXT;
1558 
1559   //=== VK_EXT_multi_draw ===
1560   struct PhysicalDeviceMultiDrawFeaturesEXT;
1561   struct PhysicalDeviceMultiDrawPropertiesEXT;
1562   struct MultiDrawInfoEXT;
1563   struct MultiDrawIndexedInfoEXT;
1564 
1565   //=== VK_EXT_image_2d_view_of_3d ===
1566   struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
1567 
1568   //=== VK_EXT_shader_tile_image ===
1569   struct PhysicalDeviceShaderTileImageFeaturesEXT;
1570   struct PhysicalDeviceShaderTileImagePropertiesEXT;
1571 
1572   //=== VK_EXT_opacity_micromap ===
1573   struct MicromapBuildInfoEXT;
1574   struct MicromapUsageEXT;
1575   struct MicromapCreateInfoEXT;
1576   struct PhysicalDeviceOpacityMicromapFeaturesEXT;
1577   struct PhysicalDeviceOpacityMicromapPropertiesEXT;
1578   struct MicromapVersionInfoEXT;
1579   struct CopyMicromapToMemoryInfoEXT;
1580   struct CopyMemoryToMicromapInfoEXT;
1581   struct CopyMicromapInfoEXT;
1582   struct MicromapBuildSizesInfoEXT;
1583   struct AccelerationStructureTrianglesOpacityMicromapEXT;
1584   struct MicromapTriangleEXT;
1585 
1586 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1587   //=== VK_NV_displacement_micromap ===
1588   struct PhysicalDeviceDisplacementMicromapFeaturesNV;
1589   struct PhysicalDeviceDisplacementMicromapPropertiesNV;
1590   struct AccelerationStructureTrianglesDisplacementMicromapNV;
1591 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1592 
1593   //=== VK_HUAWEI_cluster_culling_shader ===
1594   struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
1595   struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
1596   struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;
1597 
1598   //=== VK_EXT_border_color_swizzle ===
1599   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1600   struct SamplerBorderColorComponentMappingCreateInfoEXT;
1601 
1602   //=== VK_EXT_pageable_device_local_memory ===
1603   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1604 
1605   //=== VK_ARM_shader_core_properties ===
1606   struct PhysicalDeviceShaderCorePropertiesARM;
1607 
1608   //=== VK_ARM_scheduling_controls ===
1609   struct DeviceQueueShaderCoreControlCreateInfoARM;
1610   struct PhysicalDeviceSchedulingControlsFeaturesARM;
1611   struct PhysicalDeviceSchedulingControlsPropertiesARM;
1612 
1613   //=== VK_EXT_image_sliced_view_of_3d ===
1614   struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
1615   struct ImageViewSlicedCreateInfoEXT;
1616 
1617   //=== VK_VALVE_descriptor_set_host_mapping ===
1618   struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
1619   struct DescriptorSetBindingReferenceVALVE;
1620   struct DescriptorSetLayoutHostMappingInfoVALVE;
1621 
1622   //=== VK_EXT_depth_clamp_zero_one ===
1623   struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;
1624 
1625   //=== VK_EXT_non_seamless_cube_map ===
1626   struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
1627 
1628   //=== VK_ARM_render_pass_striped ===
1629   struct PhysicalDeviceRenderPassStripedFeaturesARM;
1630   struct PhysicalDeviceRenderPassStripedPropertiesARM;
1631   struct RenderPassStripeBeginInfoARM;
1632   struct RenderPassStripeInfoARM;
1633   struct RenderPassStripeSubmitInfoARM;
1634 
1635   //=== VK_QCOM_fragment_density_map_offset ===
1636   struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
1637   struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
1638   struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
1639 
1640   //=== VK_NV_copy_memory_indirect ===
1641   struct CopyMemoryIndirectCommandNV;
1642   struct CopyMemoryToImageIndirectCommandNV;
1643   struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
1644   struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;
1645 
1646   //=== VK_NV_memory_decompression ===
1647   struct DecompressMemoryRegionNV;
1648   struct PhysicalDeviceMemoryDecompressionFeaturesNV;
1649   struct PhysicalDeviceMemoryDecompressionPropertiesNV;
1650 
1651   //=== VK_NV_device_generated_commands_compute ===
1652   struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
1653   struct ComputePipelineIndirectBufferInfoNV;
1654   struct PipelineIndirectDeviceAddressInfoNV;
1655   struct BindPipelineIndirectCommandNV;
1656 
1657   //=== VK_NV_linear_color_attachment ===
1658   struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
1659 
1660   //=== VK_KHR_shader_maximal_reconvergence ===
1661   struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
1662 
1663   //=== VK_EXT_image_compression_control_swapchain ===
1664   struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
1665 
1666   //=== VK_QCOM_image_processing ===
1667   struct ImageViewSampleWeightCreateInfoQCOM;
1668   struct PhysicalDeviceImageProcessingFeaturesQCOM;
1669   struct PhysicalDeviceImageProcessingPropertiesQCOM;
1670 
1671   //=== VK_EXT_nested_command_buffer ===
1672   struct PhysicalDeviceNestedCommandBufferFeaturesEXT;
1673   struct PhysicalDeviceNestedCommandBufferPropertiesEXT;
1674 
1675   //=== VK_EXT_external_memory_acquire_unmodified ===
1676   struct ExternalMemoryAcquireUnmodifiedEXT;
1677 
1678   //=== VK_EXT_extended_dynamic_state3 ===
1679   struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
1680   struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
1681   struct ColorBlendEquationEXT;
1682   struct ColorBlendAdvancedEXT;
1683 
1684   //=== VK_EXT_subpass_merge_feedback ===
1685   struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
1686   struct RenderPassCreationControlEXT;
1687   struct RenderPassCreationFeedbackInfoEXT;
1688   struct RenderPassCreationFeedbackCreateInfoEXT;
1689   struct RenderPassSubpassFeedbackInfoEXT;
1690   struct RenderPassSubpassFeedbackCreateInfoEXT;
1691 
1692   //=== VK_LUNARG_direct_driver_loading ===
1693   struct DirectDriverLoadingInfoLUNARG;
1694   struct DirectDriverLoadingListLUNARG;
1695 
1696   //=== VK_EXT_shader_module_identifier ===
1697   struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
1698   struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
1699   struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
1700   struct ShaderModuleIdentifierEXT;
1701 
1702   //=== VK_EXT_rasterization_order_attachment_access ===
1703   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1704   using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1705 
1706   //=== VK_NV_optical_flow ===
1707   struct PhysicalDeviceOpticalFlowFeaturesNV;
1708   struct PhysicalDeviceOpticalFlowPropertiesNV;
1709   struct OpticalFlowImageFormatInfoNV;
1710   struct OpticalFlowImageFormatPropertiesNV;
1711   struct OpticalFlowSessionCreateInfoNV;
1712   struct OpticalFlowSessionCreatePrivateDataInfoNV;
1713   struct OpticalFlowExecuteInfoNV;
1714 
1715   //=== VK_EXT_legacy_dithering ===
1716   struct PhysicalDeviceLegacyDitheringFeaturesEXT;
1717 
1718 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
1719   //=== VK_ANDROID_external_format_resolve ===
1720   struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
1721   struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
1722   struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
1723 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1724 
1725   //=== VK_AMD_anti_lag ===
1726   struct PhysicalDeviceAntiLagFeaturesAMD;
1727   struct AntiLagDataAMD;
1728   struct AntiLagPresentationInfoAMD;
1729 
1730   //=== VK_KHR_ray_tracing_position_fetch ===
1731   struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
1732 
1733   //=== VK_EXT_shader_object ===
1734   struct PhysicalDeviceShaderObjectFeaturesEXT;
1735   struct PhysicalDeviceShaderObjectPropertiesEXT;
1736   struct ShaderCreateInfoEXT;
1737 
1738   //=== VK_KHR_pipeline_binary ===
1739   struct PhysicalDevicePipelineBinaryFeaturesKHR;
1740   struct PhysicalDevicePipelineBinaryPropertiesKHR;
1741   struct DevicePipelineBinaryInternalCacheControlKHR;
1742   struct PipelineBinaryKeyKHR;
1743   struct PipelineBinaryDataKHR;
1744   struct PipelineBinaryKeysAndDataKHR;
1745   struct PipelineBinaryCreateInfoKHR;
1746   struct PipelineBinaryInfoKHR;
1747   struct ReleaseCapturedPipelineDataInfoKHR;
1748   struct PipelineBinaryDataInfoKHR;
1749   struct PipelineCreateInfoKHR;
1750   struct PipelineBinaryHandlesInfoKHR;
1751 
1752   //=== VK_QCOM_tile_properties ===
1753   struct PhysicalDeviceTilePropertiesFeaturesQCOM;
1754   struct TilePropertiesQCOM;
1755 
1756   //=== VK_SEC_amigo_profiling ===
1757   struct PhysicalDeviceAmigoProfilingFeaturesSEC;
1758   struct AmigoProfilingSubmitInfoSEC;
1759 
1760   //=== VK_QCOM_multiview_per_view_viewports ===
1761   struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
1762 
1763   //=== VK_NV_ray_tracing_invocation_reorder ===
1764   struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
1765   struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
1766 
1767   //=== VK_NV_extended_sparse_address_space ===
1768   struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
1769   struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
1770 
1771   //=== VK_EXT_mutable_descriptor_type ===
1772   struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1773   using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1774   struct MutableDescriptorTypeListEXT;
1775   using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
1776   struct MutableDescriptorTypeCreateInfoEXT;
1777   using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
1778 
1779   //=== VK_EXT_legacy_vertex_attributes ===
1780   struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT;
1781   struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT;
1782 
1783   //=== VK_EXT_layer_settings ===
1784   struct LayerSettingsCreateInfoEXT;
1785   struct LayerSettingEXT;
1786 
1787   //=== VK_ARM_shader_core_builtins ===
1788   struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
1789   struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
1790 
1791   //=== VK_EXT_pipeline_library_group_handles ===
1792   struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
1793 
1794   //=== VK_EXT_dynamic_rendering_unused_attachments ===
1795   struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
1796 
1797   //=== VK_NV_low_latency2 ===
1798   struct LatencySleepModeInfoNV;
1799   struct LatencySleepInfoNV;
1800   struct SetLatencyMarkerInfoNV;
1801   struct GetLatencyMarkerInfoNV;
1802   struct LatencyTimingsFrameReportNV;
1803   struct LatencySubmissionPresentIdNV;
1804   struct SwapchainLatencyCreateInfoNV;
1805   struct OutOfBandQueueTypeInfoNV;
1806   struct LatencySurfaceCapabilitiesNV;
1807 
1808   //=== VK_KHR_cooperative_matrix ===
1809   struct CooperativeMatrixPropertiesKHR;
1810   struct PhysicalDeviceCooperativeMatrixFeaturesKHR;
1811   struct PhysicalDeviceCooperativeMatrixPropertiesKHR;
1812 
1813   //=== VK_QCOM_multiview_per_view_render_areas ===
1814   struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
1815   struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
1816 
1817   //=== VK_KHR_video_decode_av1 ===
1818   struct VideoDecodeAV1ProfileInfoKHR;
1819   struct VideoDecodeAV1CapabilitiesKHR;
1820   struct VideoDecodeAV1SessionParametersCreateInfoKHR;
1821   struct VideoDecodeAV1PictureInfoKHR;
1822   struct VideoDecodeAV1DpbSlotInfoKHR;
1823 
1824   //=== VK_KHR_video_maintenance1 ===
1825   struct PhysicalDeviceVideoMaintenance1FeaturesKHR;
1826   struct VideoInlineQueryInfoKHR;
1827 
1828   //=== VK_NV_per_stage_descriptor_set ===
1829   struct PhysicalDevicePerStageDescriptorSetFeaturesNV;
1830 
1831   //=== VK_QCOM_image_processing2 ===
1832   struct PhysicalDeviceImageProcessing2FeaturesQCOM;
1833   struct PhysicalDeviceImageProcessing2PropertiesQCOM;
1834   struct SamplerBlockMatchWindowCreateInfoQCOM;
1835 
1836   //=== VK_QCOM_filter_cubic_weights ===
1837   struct PhysicalDeviceCubicWeightsFeaturesQCOM;
1838   struct SamplerCubicWeightsCreateInfoQCOM;
1839   struct BlitImageCubicWeightsInfoQCOM;
1840 
1841   //=== VK_QCOM_ycbcr_degamma ===
1842   struct PhysicalDeviceYcbcrDegammaFeaturesQCOM;
1843   struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
1844 
1845   //=== VK_QCOM_filter_cubic_clamp ===
1846   struct PhysicalDeviceCubicClampFeaturesQCOM;
1847 
1848   //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1849   struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
1850 
1851 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1852   //=== VK_QNX_external_memory_screen_buffer ===
1853   struct ScreenBufferPropertiesQNX;
1854   struct ScreenBufferFormatPropertiesQNX;
1855   struct ImportScreenBufferInfoQNX;
1856   struct ExternalFormatQNX;
1857   struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
1858 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1859 
1860   //=== VK_MSFT_layered_driver ===
1861   struct PhysicalDeviceLayeredDriverPropertiesMSFT;
1862 
1863   //=== VK_KHR_calibrated_timestamps ===
1864   struct CalibratedTimestampInfoKHR;
1865   using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR;
1866 
1867   //=== VK_KHR_maintenance6 ===
1868   struct SetDescriptorBufferOffsetsInfoEXT;
1869   struct BindDescriptorBufferEmbeddedSamplersInfoEXT;
1870 
1871   //=== VK_NV_descriptor_pool_overallocation ===
1872   struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
1873 
1874   //=== VK_NV_raw_access_chains ===
1875   struct PhysicalDeviceRawAccessChainsFeaturesNV;
1876 
1877   //=== VK_KHR_shader_relaxed_extended_instruction ===
1878   struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
1879 
1880   //=== VK_NV_command_buffer_inheritance ===
1881   struct PhysicalDeviceCommandBufferInheritanceFeaturesNV;
1882 
1883   //=== VK_KHR_maintenance7 ===
1884   struct PhysicalDeviceMaintenance7FeaturesKHR;
1885   struct PhysicalDeviceMaintenance7PropertiesKHR;
1886   struct PhysicalDeviceLayeredApiPropertiesListKHR;
1887   struct PhysicalDeviceLayeredApiPropertiesKHR;
1888   struct PhysicalDeviceLayeredApiVulkanPropertiesKHR;
1889 
1890   //=== VK_NV_shader_atomic_float16_vector ===
1891   struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
1892 
1893   //=== VK_EXT_shader_replicated_composites ===
1894   struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
1895 
1896   //=== VK_NV_ray_tracing_validation ===
1897   struct PhysicalDeviceRayTracingValidationFeaturesNV;
1898 
1899   //=== VK_MESA_image_alignment_control ===
1900   struct PhysicalDeviceImageAlignmentControlFeaturesMESA;
1901   struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
1902   struct ImageAlignmentControlCreateInfoMESA;
1903 
1904   //===================================
1905   //=== HANDLE forward declarations ===
1906   //===================================
1907 
1908   //=== VK_VERSION_1_0 ===
1909   class Instance;
1910   class PhysicalDevice;
1911   class Device;
1912   class Queue;
1913   class DeviceMemory;
1914   class Fence;
1915   class Semaphore;
1916   class Event;
1917   class QueryPool;
1918   class Buffer;
1919   class BufferView;
1920   class Image;
1921   class ImageView;
1922   class ShaderModule;
1923   class PipelineCache;
1924   class Pipeline;
1925   class PipelineLayout;
1926   class Sampler;
1927   class DescriptorPool;
1928   class DescriptorSet;
1929   class DescriptorSetLayout;
1930   class Framebuffer;
1931   class RenderPass;
1932   class CommandPool;
1933   class CommandBuffer;
1934 
1935   //=== VK_VERSION_1_1 ===
1936   class SamplerYcbcrConversion;
1937   class DescriptorUpdateTemplate;
1938 
1939   //=== VK_VERSION_1_3 ===
1940   class PrivateDataSlot;
1941 
1942   //=== VK_KHR_surface ===
1943   class SurfaceKHR;
1944 
1945   //=== VK_KHR_swapchain ===
1946   class SwapchainKHR;
1947 
1948   //=== VK_KHR_display ===
1949   class DisplayKHR;
1950   class DisplayModeKHR;
1951 
1952   //=== VK_EXT_debug_report ===
1953   class DebugReportCallbackEXT;
1954 
1955   //=== VK_KHR_video_queue ===
1956   class VideoSessionKHR;
1957   class VideoSessionParametersKHR;
1958 
1959   //=== VK_NVX_binary_import ===
1960   class CuModuleNVX;
1961   class CuFunctionNVX;
1962 
1963   //=== VK_EXT_debug_utils ===
1964   class DebugUtilsMessengerEXT;
1965 
1966   //=== VK_KHR_acceleration_structure ===
1967   class AccelerationStructureKHR;
1968 
1969   //=== VK_EXT_validation_cache ===
1970   class ValidationCacheEXT;
1971 
1972   //=== VK_NV_ray_tracing ===
1973   class AccelerationStructureNV;
1974 
1975   //=== VK_INTEL_performance_query ===
1976   class PerformanceConfigurationINTEL;
1977 
1978   //=== VK_KHR_deferred_host_operations ===
1979   class DeferredOperationKHR;
1980 
1981   //=== VK_NV_device_generated_commands ===
1982   class IndirectCommandsLayoutNV;
1983 
1984 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1985   //=== VK_NV_cuda_kernel_launch ===
1986   class CudaModuleNV;
1987   class CudaFunctionNV;
1988 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1989 
1990 #if defined( VK_USE_PLATFORM_FUCHSIA )
1991   //=== VK_FUCHSIA_buffer_collection ===
1992   class BufferCollectionFUCHSIA;
1993 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1994 
1995   //=== VK_EXT_opacity_micromap ===
1996   class MicromapEXT;
1997 
1998   //=== VK_NV_optical_flow ===
1999   class OpticalFlowSessionNV;
2000 
2001   //=== VK_EXT_shader_object ===
2002   class ShaderEXT;
2003 
2004   //=== VK_KHR_pipeline_binary ===
2005   class PipelineBinaryKHR;
2006 
2007 #ifndef VULKAN_HPP_NO_SMART_HANDLE
2008   //======================
2009   //=== UNIQUE HANDLEs ===
2010   //======================
2011 
2012   //=== VK_VERSION_1_0 ===
2013   template <typename Dispatch>
2014   class UniqueHandleTraits<Instance, Dispatch>
2015   {
2016   public:
2017     using deleter = ObjectDestroy<NoParent, Dispatch>;
2018   };
2019 
2020   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2021 
2022   template <typename Dispatch>
2023   class UniqueHandleTraits<Device, Dispatch>
2024   {
2025   public:
2026     using deleter = ObjectDestroy<NoParent, Dispatch>;
2027   };
2028 
2029   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2030 
2031   template <typename Dispatch>
2032   class UniqueHandleTraits<DeviceMemory, Dispatch>
2033   {
2034   public:
2035     using deleter = ObjectFree<Device, Dispatch>;
2036   };
2037 
2038   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2039 
2040   template <typename Dispatch>
2041   class UniqueHandleTraits<Fence, Dispatch>
2042   {
2043   public:
2044     using deleter = ObjectDestroy<Device, Dispatch>;
2045   };
2046 
2047   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2048 
2049   template <typename Dispatch>
2050   class UniqueHandleTraits<Semaphore, Dispatch>
2051   {
2052   public:
2053     using deleter = ObjectDestroy<Device, Dispatch>;
2054   };
2055 
2056   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2057 
2058   template <typename Dispatch>
2059   class UniqueHandleTraits<Event, Dispatch>
2060   {
2061   public:
2062     using deleter = ObjectDestroy<Device, Dispatch>;
2063   };
2064 
2065   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2066 
2067   template <typename Dispatch>
2068   class UniqueHandleTraits<QueryPool, Dispatch>
2069   {
2070   public:
2071     using deleter = ObjectDestroy<Device, Dispatch>;
2072   };
2073 
2074   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2075 
2076   template <typename Dispatch>
2077   class UniqueHandleTraits<Buffer, Dispatch>
2078   {
2079   public:
2080     using deleter = ObjectDestroy<Device, Dispatch>;
2081   };
2082 
2083   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2084 
2085   template <typename Dispatch>
2086   class UniqueHandleTraits<BufferView, Dispatch>
2087   {
2088   public:
2089     using deleter = ObjectDestroy<Device, Dispatch>;
2090   };
2091 
2092   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2093 
2094   template <typename Dispatch>
2095   class UniqueHandleTraits<Image, Dispatch>
2096   {
2097   public:
2098     using deleter = ObjectDestroy<Device, Dispatch>;
2099   };
2100 
2101   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2102 
2103   template <typename Dispatch>
2104   class UniqueHandleTraits<ImageView, Dispatch>
2105   {
2106   public:
2107     using deleter = ObjectDestroy<Device, Dispatch>;
2108   };
2109 
2110   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2111 
2112   template <typename Dispatch>
2113   class UniqueHandleTraits<ShaderModule, Dispatch>
2114   {
2115   public:
2116     using deleter = ObjectDestroy<Device, Dispatch>;
2117   };
2118 
2119   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2120 
2121   template <typename Dispatch>
2122   class UniqueHandleTraits<PipelineCache, Dispatch>
2123   {
2124   public:
2125     using deleter = ObjectDestroy<Device, Dispatch>;
2126   };
2127 
2128   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2129 
2130   template <typename Dispatch>
2131   class UniqueHandleTraits<Pipeline, Dispatch>
2132   {
2133   public:
2134     using deleter = ObjectDestroy<Device, Dispatch>;
2135   };
2136 
2137   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2138 
2139   template <typename Dispatch>
2140   class UniqueHandleTraits<PipelineLayout, Dispatch>
2141   {
2142   public:
2143     using deleter = ObjectDestroy<Device, Dispatch>;
2144   };
2145 
2146   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2147 
2148   template <typename Dispatch>
2149   class UniqueHandleTraits<Sampler, Dispatch>
2150   {
2151   public:
2152     using deleter = ObjectDestroy<Device, Dispatch>;
2153   };
2154 
2155   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2156 
2157   template <typename Dispatch>
2158   class UniqueHandleTraits<DescriptorPool, Dispatch>
2159   {
2160   public:
2161     using deleter = ObjectDestroy<Device, Dispatch>;
2162   };
2163 
2164   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2165 
2166   template <typename Dispatch>
2167   class UniqueHandleTraits<DescriptorSet, Dispatch>
2168   {
2169   public:
2170     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
2171   };
2172 
2173   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2174 
2175   template <typename Dispatch>
2176   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
2177   {
2178   public:
2179     using deleter = ObjectDestroy<Device, Dispatch>;
2180   };
2181 
2182   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2183 
2184   template <typename Dispatch>
2185   class UniqueHandleTraits<Framebuffer, Dispatch>
2186   {
2187   public:
2188     using deleter = ObjectDestroy<Device, Dispatch>;
2189   };
2190 
2191   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2192 
2193   template <typename Dispatch>
2194   class UniqueHandleTraits<RenderPass, Dispatch>
2195   {
2196   public:
2197     using deleter = ObjectDestroy<Device, Dispatch>;
2198   };
2199 
2200   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2201 
2202   template <typename Dispatch>
2203   class UniqueHandleTraits<CommandPool, Dispatch>
2204   {
2205   public:
2206     using deleter = ObjectDestroy<Device, Dispatch>;
2207   };
2208 
2209   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2210 
2211   template <typename Dispatch>
2212   class UniqueHandleTraits<CommandBuffer, Dispatch>
2213   {
2214   public:
2215     using deleter = PoolFree<Device, CommandPool, Dispatch>;
2216   };
2217 
2218   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2219 
2220   //=== VK_VERSION_1_1 ===
2221   template <typename Dispatch>
2222   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
2223   {
2224   public:
2225     using deleter = ObjectDestroy<Device, Dispatch>;
2226   };
2227 
2228   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2229   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2230 
2231   template <typename Dispatch>
2232   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
2233   {
2234   public:
2235     using deleter = ObjectDestroy<Device, Dispatch>;
2236   };
2237 
2238   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2239   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2240 
2241   //=== VK_VERSION_1_3 ===
2242   template <typename Dispatch>
2243   class UniqueHandleTraits<PrivateDataSlot, Dispatch>
2244   {
2245   public:
2246     using deleter = ObjectDestroy<Device, Dispatch>;
2247   };
2248 
2249   using UniquePrivateDataSlot    = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2250   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2251 
2252   //=== VK_KHR_surface ===
2253   template <typename Dispatch>
2254   class UniqueHandleTraits<SurfaceKHR, Dispatch>
2255   {
2256   public:
2257     using deleter = ObjectDestroy<Instance, Dispatch>;
2258   };
2259 
2260   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2261 
2262   //=== VK_KHR_swapchain ===
2263   template <typename Dispatch>
2264   class UniqueHandleTraits<SwapchainKHR, Dispatch>
2265   {
2266   public:
2267     using deleter = ObjectDestroy<Device, Dispatch>;
2268   };
2269 
2270   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2271 
2272   //=== VK_KHR_display ===
2273   template <typename Dispatch>
2274   class UniqueHandleTraits<DisplayKHR, Dispatch>
2275   {
2276   public:
2277     using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
2278   };
2279 
2280   using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2281 
2282   //=== VK_EXT_debug_report ===
2283   template <typename Dispatch>
2284   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
2285   {
2286   public:
2287     using deleter = ObjectDestroy<Instance, Dispatch>;
2288   };
2289 
2290   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2291 
2292   //=== VK_KHR_video_queue ===
2293   template <typename Dispatch>
2294   class UniqueHandleTraits<VideoSessionKHR, Dispatch>
2295   {
2296   public:
2297     using deleter = ObjectDestroy<Device, Dispatch>;
2298   };
2299 
2300   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2301 
2302   template <typename Dispatch>
2303   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
2304   {
2305   public:
2306     using deleter = ObjectDestroy<Device, Dispatch>;
2307   };
2308 
2309   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2310 
2311   //=== VK_NVX_binary_import ===
2312   template <typename Dispatch>
2313   class UniqueHandleTraits<CuModuleNVX, Dispatch>
2314   {
2315   public:
2316     using deleter = ObjectDestroy<Device, Dispatch>;
2317   };
2318 
2319   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2320 
2321   template <typename Dispatch>
2322   class UniqueHandleTraits<CuFunctionNVX, Dispatch>
2323   {
2324   public:
2325     using deleter = ObjectDestroy<Device, Dispatch>;
2326   };
2327 
2328   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2329 
2330   //=== VK_EXT_debug_utils ===
2331   template <typename Dispatch>
2332   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
2333   {
2334   public:
2335     using deleter = ObjectDestroy<Instance, Dispatch>;
2336   };
2337 
2338   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2339 
2340   //=== VK_KHR_acceleration_structure ===
2341   template <typename Dispatch>
2342   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
2343   {
2344   public:
2345     using deleter = ObjectDestroy<Device, Dispatch>;
2346   };
2347 
2348   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2349 
2350   //=== VK_EXT_validation_cache ===
2351   template <typename Dispatch>
2352   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
2353   {
2354   public:
2355     using deleter = ObjectDestroy<Device, Dispatch>;
2356   };
2357 
2358   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2359 
2360   //=== VK_NV_ray_tracing ===
2361   template <typename Dispatch>
2362   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
2363   {
2364   public:
2365     using deleter = ObjectDestroy<Device, Dispatch>;
2366   };
2367 
2368   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2369 
2370   //=== VK_INTEL_performance_query ===
2371   template <typename Dispatch>
2372   class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
2373   {
2374   public:
2375     using deleter = ObjectDestroy<Device, Dispatch>;
2376   };
2377 
2378   using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2379 
2380   //=== VK_KHR_deferred_host_operations ===
2381   template <typename Dispatch>
2382   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
2383   {
2384   public:
2385     using deleter = ObjectDestroy<Device, Dispatch>;
2386   };
2387 
2388   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2389 
2390   //=== VK_NV_device_generated_commands ===
2391   template <typename Dispatch>
2392   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
2393   {
2394   public:
2395     using deleter = ObjectDestroy<Device, Dispatch>;
2396   };
2397 
2398   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2399 
2400 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
2401   //=== VK_NV_cuda_kernel_launch ===
2402   template <typename Dispatch>
2403   class UniqueHandleTraits<CudaModuleNV, Dispatch>
2404   {
2405   public:
2406     using deleter = ObjectDestroy<Device, Dispatch>;
2407   };
2408 
2409   using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2410 
2411   template <typename Dispatch>
2412   class UniqueHandleTraits<CudaFunctionNV, Dispatch>
2413   {
2414   public:
2415     using deleter = ObjectDestroy<Device, Dispatch>;
2416   };
2417 
2418   using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2419 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
2420 
2421 #  if defined( VK_USE_PLATFORM_FUCHSIA )
2422   //=== VK_FUCHSIA_buffer_collection ===
2423   template <typename Dispatch>
2424   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
2425   {
2426   public:
2427     using deleter = ObjectDestroy<Device, Dispatch>;
2428   };
2429 
2430   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2431 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
2432 
2433   //=== VK_EXT_opacity_micromap ===
2434   template <typename Dispatch>
2435   class UniqueHandleTraits<MicromapEXT, Dispatch>
2436   {
2437   public:
2438     using deleter = ObjectDestroy<Device, Dispatch>;
2439   };
2440 
2441   using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2442 
2443   //=== VK_NV_optical_flow ===
2444   template <typename Dispatch>
2445   class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
2446   {
2447   public:
2448     using deleter = ObjectDestroy<Device, Dispatch>;
2449   };
2450 
2451   using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2452 
2453   //=== VK_EXT_shader_object ===
2454   template <typename Dispatch>
2455   class UniqueHandleTraits<ShaderEXT, Dispatch>
2456   {
2457   public:
2458     using deleter = ObjectDestroy<Device, Dispatch>;
2459   };
2460 
2461   using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2462 
2463   //=== VK_KHR_pipeline_binary ===
2464   template <typename Dispatch>
2465   class UniqueHandleTraits<PipelineBinaryKHR, Dispatch>
2466   {
2467   public:
2468     using deleter = ObjectDestroy<Device, Dispatch>;
2469   };
2470 
2471   using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2472 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
2473 
2474   //===============
2475   //=== HANDLEs ===
2476   //===============
2477 
2478   template <typename Type>
2479   struct isVulkanHandleType
2480   {
2481     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
2482   };
2483 
2484   class SurfaceKHR
2485   {
2486   public:
2487     using CType      = VkSurfaceKHR;
2488     using NativeType = VkSurfaceKHR;
2489 
2490     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
2491     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2492       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
2493 
2494   public:
SurfaceKHR()2495     SurfaceKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
2496     SurfaceKHR( SurfaceKHR const & rhs )             = default;
2497     SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
2498 
2499 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
2500     SurfaceKHR( SurfaceKHR && rhs )             = default;
2501     SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;
2502 #else
SurfaceKHR(SurfaceKHR && rhs)2503     SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) ) {}
2504 
operator =(SurfaceKHR && rhs)2505     SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
2506     {
2507       m_surfaceKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} );
2508       return *this;
2509     }
2510 #endif
2511 
SurfaceKHR(std::nullptr_t)2512     VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2513 
SurfaceKHR(VkSurfaceKHR surfaceKHR)2514     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
2515 
2516 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSurfaceKHR surfaceKHR)2517     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2518     {
2519       m_surfaceKHR = surfaceKHR;
2520       return *this;
2521     }
2522 #endif
2523 
operator =(std::nullptr_t)2524     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2525     {
2526       m_surfaceKHR = {};
2527       return *this;
2528     }
2529 
2530 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2531     auto operator<=>( SurfaceKHR const & ) const = default;
2532 #else
operator ==(SurfaceKHR const & rhs) const2533     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2534     {
2535       return m_surfaceKHR == rhs.m_surfaceKHR;
2536     }
2537 
operator !=(SurfaceKHR const & rhs) const2538     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2539     {
2540       return m_surfaceKHR != rhs.m_surfaceKHR;
2541     }
2542 
operator <(SurfaceKHR const & rhs) const2543     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2544     {
2545       return m_surfaceKHR < rhs.m_surfaceKHR;
2546     }
2547 #endif
2548 
operator VkSurfaceKHR() const2549     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
2550     {
2551       return m_surfaceKHR;
2552     }
2553 
operator bool() const2554     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2555     {
2556       return m_surfaceKHR != VK_NULL_HANDLE;
2557     }
2558 
operator !() const2559     bool operator!() const VULKAN_HPP_NOEXCEPT
2560     {
2561       return m_surfaceKHR == VK_NULL_HANDLE;
2562     }
2563 
2564   private:
2565     VkSurfaceKHR m_surfaceKHR = {};
2566   };
2567 
2568   template <>
2569   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
2570   {
2571     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2572   };
2573 
2574   template <>
2575   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
2576   {
2577     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2578   };
2579 
2580 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2581   template <>
2582   struct CppType<VkSurfaceKHR, VK_NULL_HANDLE>
2583   {
2584     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2585   };
2586 #endif
2587 
2588   template <>
2589   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
2590   {
2591     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2592   };
2593 
2594   class DebugReportCallbackEXT
2595   {
2596   public:
2597     using CType      = VkDebugReportCallbackEXT;
2598     using NativeType = VkDebugReportCallbackEXT;
2599 
2600     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
2601     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2602       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
2603 
2604   public:
DebugReportCallbackEXT()2605     DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
2606     DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs )             = default;
2607     DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default;
2608 
2609 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
2610     DebugReportCallbackEXT( DebugReportCallbackEXT && rhs )             = default;
2611     DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default;
2612 #else
DebugReportCallbackEXT(DebugReportCallbackEXT && rhs)2613     DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
2614       : m_debugReportCallbackEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ) )
2615     {
2616     }
2617 
operator =(DebugReportCallbackEXT && rhs)2618     DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
2619     {
2620       m_debugReportCallbackEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} );
2621       return *this;
2622     }
2623 #endif
2624 
DebugReportCallbackEXT(std::nullptr_t)2625     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2626 
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)2627     VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2628       : m_debugReportCallbackEXT( debugReportCallbackEXT )
2629     {
2630     }
2631 
2632 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)2633     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2634     {
2635       m_debugReportCallbackEXT = debugReportCallbackEXT;
2636       return *this;
2637     }
2638 #endif
2639 
operator =(std::nullptr_t)2640     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2641     {
2642       m_debugReportCallbackEXT = {};
2643       return *this;
2644     }
2645 
2646 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2647     auto operator<=>( DebugReportCallbackEXT const & ) const = default;
2648 #else
operator ==(DebugReportCallbackEXT const & rhs) const2649     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2650     {
2651       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
2652     }
2653 
operator !=(DebugReportCallbackEXT const & rhs) const2654     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2655     {
2656       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
2657     }
2658 
operator <(DebugReportCallbackEXT const & rhs) const2659     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2660     {
2661       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
2662     }
2663 #endif
2664 
operator VkDebugReportCallbackEXT() const2665     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
2666     {
2667       return m_debugReportCallbackEXT;
2668     }
2669 
operator bool() const2670     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2671     {
2672       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
2673     }
2674 
operator !() const2675     bool operator!() const VULKAN_HPP_NOEXCEPT
2676     {
2677       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
2678     }
2679 
2680   private:
2681     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
2682   };
2683 
2684   template <>
2685   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
2686   {
2687     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2688   };
2689 
2690   template <>
2691   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
2692   {
2693     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2694   };
2695 
2696 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2697   template <>
2698   struct CppType<VkDebugReportCallbackEXT, VK_NULL_HANDLE>
2699   {
2700     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2701   };
2702 #endif
2703 
2704   template <>
2705   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
2706   {
2707     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2708   };
2709 
2710   class DebugUtilsMessengerEXT
2711   {
2712   public:
2713     using CType      = VkDebugUtilsMessengerEXT;
2714     using NativeType = VkDebugUtilsMessengerEXT;
2715 
2716     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
2717     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2718       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2719 
2720   public:
DebugUtilsMessengerEXT()2721     DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
2722     DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs )             = default;
2723     DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
2724 
2725 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
2726     DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs )             = default;
2727     DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;
2728 #else
DebugUtilsMessengerEXT(DebugUtilsMessengerEXT && rhs)2729     DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
2730       : m_debugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) )
2731     {
2732     }
2733 
operator =(DebugUtilsMessengerEXT && rhs)2734     DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
2735     {
2736       m_debugUtilsMessengerEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} );
2737       return *this;
2738     }
2739 #endif
2740 
DebugUtilsMessengerEXT(std::nullptr_t)2741     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2742 
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2743     VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2744       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
2745     {
2746     }
2747 
2748 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)2749     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2750     {
2751       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
2752       return *this;
2753     }
2754 #endif
2755 
operator =(std::nullptr_t)2756     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2757     {
2758       m_debugUtilsMessengerEXT = {};
2759       return *this;
2760     }
2761 
2762 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2763     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
2764 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const2765     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2766     {
2767       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
2768     }
2769 
operator !=(DebugUtilsMessengerEXT const & rhs) const2770     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2771     {
2772       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
2773     }
2774 
operator <(DebugUtilsMessengerEXT const & rhs) const2775     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
2776     {
2777       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
2778     }
2779 #endif
2780 
operator VkDebugUtilsMessengerEXT() const2781     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
2782     {
2783       return m_debugUtilsMessengerEXT;
2784     }
2785 
operator bool() const2786     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2787     {
2788       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
2789     }
2790 
operator !() const2791     bool operator!() const VULKAN_HPP_NOEXCEPT
2792     {
2793       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
2794     }
2795 
2796   private:
2797     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
2798   };
2799 
2800   template <>
2801   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
2802   {
2803     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2804   };
2805 
2806 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2807   template <>
2808   struct CppType<VkDebugUtilsMessengerEXT, VK_NULL_HANDLE>
2809   {
2810     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2811   };
2812 #endif
2813 
2814   template <>
2815   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
2816   {
2817     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2818   };
2819 
2820   class DisplayKHR
2821   {
2822   public:
2823     using CType      = VkDisplayKHR;
2824     using NativeType = VkDisplayKHR;
2825 
2826     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
2827     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2828       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
2829 
2830   public:
DisplayKHR()2831     DisplayKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
2832     DisplayKHR( DisplayKHR const & rhs )             = default;
2833     DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
2834 
2835 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
2836     DisplayKHR( DisplayKHR && rhs )             = default;
2837     DisplayKHR & operator=( DisplayKHR && rhs ) = default;
2838 #else
DisplayKHR(DisplayKHR && rhs)2839     DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} ) ) {}
2840 
operator =(DisplayKHR && rhs)2841     DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
2842     {
2843       m_displayKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} );
2844       return *this;
2845     }
2846 #endif
2847 
DisplayKHR(std::nullptr_t)2848     VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2849 
DisplayKHR(VkDisplayKHR displayKHR)2850     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
2851 
2852 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDisplayKHR displayKHR)2853     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
2854     {
2855       m_displayKHR = displayKHR;
2856       return *this;
2857     }
2858 #endif
2859 
operator =(std::nullptr_t)2860     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2861     {
2862       m_displayKHR = {};
2863       return *this;
2864     }
2865 
2866 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2867     auto operator<=>( DisplayKHR const & ) const = default;
2868 #else
operator ==(DisplayKHR const & rhs) const2869     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2870     {
2871       return m_displayKHR == rhs.m_displayKHR;
2872     }
2873 
operator !=(DisplayKHR const & rhs) const2874     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2875     {
2876       return m_displayKHR != rhs.m_displayKHR;
2877     }
2878 
operator <(DisplayKHR const & rhs) const2879     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2880     {
2881       return m_displayKHR < rhs.m_displayKHR;
2882     }
2883 #endif
2884 
operator VkDisplayKHR() const2885     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
2886     {
2887       return m_displayKHR;
2888     }
2889 
operator bool() const2890     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2891     {
2892       return m_displayKHR != VK_NULL_HANDLE;
2893     }
2894 
operator !() const2895     bool operator!() const VULKAN_HPP_NOEXCEPT
2896     {
2897       return m_displayKHR == VK_NULL_HANDLE;
2898     }
2899 
2900   private:
2901     VkDisplayKHR m_displayKHR = {};
2902   };
2903 
2904   template <>
2905   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
2906   {
2907     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2908   };
2909 
2910   template <>
2911   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
2912   {
2913     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2914   };
2915 
2916 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
2917   template <>
2918   struct CppType<VkDisplayKHR, VK_NULL_HANDLE>
2919   {
2920     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2921   };
2922 #endif
2923 
2924   template <>
2925   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
2926   {
2927     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2928   };
2929 
2930   class SwapchainKHR
2931   {
2932   public:
2933     using CType      = VkSwapchainKHR;
2934     using NativeType = VkSwapchainKHR;
2935 
2936     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
2937     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2938       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
2939 
2940   public:
SwapchainKHR()2941     SwapchainKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
2942     SwapchainKHR( SwapchainKHR const & rhs )             = default;
2943     SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
2944 
2945 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
2946     SwapchainKHR( SwapchainKHR && rhs )             = default;
2947     SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;
2948 #else
SwapchainKHR(SwapchainKHR && rhs)2949     SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) ) {}
2950 
operator =(SwapchainKHR && rhs)2951     SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
2952     {
2953       m_swapchainKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} );
2954       return *this;
2955     }
2956 #endif
2957 
SwapchainKHR(std::nullptr_t)2958     VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2959 
SwapchainKHR(VkSwapchainKHR swapchainKHR)2960     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
2961 
2962 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSwapchainKHR swapchainKHR)2963     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
2964     {
2965       m_swapchainKHR = swapchainKHR;
2966       return *this;
2967     }
2968 #endif
2969 
operator =(std::nullptr_t)2970     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2971     {
2972       m_swapchainKHR = {};
2973       return *this;
2974     }
2975 
2976 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2977     auto operator<=>( SwapchainKHR const & ) const = default;
2978 #else
operator ==(SwapchainKHR const & rhs) const2979     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2980     {
2981       return m_swapchainKHR == rhs.m_swapchainKHR;
2982     }
2983 
operator !=(SwapchainKHR const & rhs) const2984     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2985     {
2986       return m_swapchainKHR != rhs.m_swapchainKHR;
2987     }
2988 
operator <(SwapchainKHR const & rhs) const2989     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2990     {
2991       return m_swapchainKHR < rhs.m_swapchainKHR;
2992     }
2993 #endif
2994 
operator VkSwapchainKHR() const2995     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
2996     {
2997       return m_swapchainKHR;
2998     }
2999 
operator bool() const3000     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3001     {
3002       return m_swapchainKHR != VK_NULL_HANDLE;
3003     }
3004 
operator !() const3005     bool operator!() const VULKAN_HPP_NOEXCEPT
3006     {
3007       return m_swapchainKHR == VK_NULL_HANDLE;
3008     }
3009 
3010   private:
3011     VkSwapchainKHR m_swapchainKHR = {};
3012   };
3013 
3014   template <>
3015   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
3016   {
3017     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
3018   };
3019 
3020   template <>
3021   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
3022   {
3023     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
3024   };
3025 
3026 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3027   template <>
3028   struct CppType<VkSwapchainKHR, VK_NULL_HANDLE>
3029   {
3030     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
3031   };
3032 #endif
3033 
3034   template <>
3035   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
3036   {
3037     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3038   };
3039 
3040   class Semaphore
3041   {
3042   public:
3043     using CType      = VkSemaphore;
3044     using NativeType = VkSemaphore;
3045 
3046     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
3047     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3048       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
3049 
3050   public:
Semaphore()3051     Semaphore() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3052     Semaphore( Semaphore const & rhs )             = default;
3053     Semaphore & operator=( Semaphore const & rhs ) = default;
3054 
3055 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3056     Semaphore( Semaphore && rhs )             = default;
3057     Semaphore & operator=( Semaphore && rhs ) = default;
3058 #else
Semaphore(Semaphore && rhs)3059     Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) {}
3060 
operator =(Semaphore && rhs)3061     Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
3062     {
3063       m_semaphore = VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} );
3064       return *this;
3065     }
3066 #endif
3067 
Semaphore(std::nullptr_t)3068     VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3069 
Semaphore(VkSemaphore semaphore)3070     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
3071 
3072 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSemaphore semaphore)3073     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
3074     {
3075       m_semaphore = semaphore;
3076       return *this;
3077     }
3078 #endif
3079 
operator =(std::nullptr_t)3080     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3081     {
3082       m_semaphore = {};
3083       return *this;
3084     }
3085 
3086 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3087     auto operator<=>( Semaphore const & ) const = default;
3088 #else
operator ==(Semaphore const & rhs) const3089     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
3090     {
3091       return m_semaphore == rhs.m_semaphore;
3092     }
3093 
operator !=(Semaphore const & rhs) const3094     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
3095     {
3096       return m_semaphore != rhs.m_semaphore;
3097     }
3098 
operator <(Semaphore const & rhs) const3099     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
3100     {
3101       return m_semaphore < rhs.m_semaphore;
3102     }
3103 #endif
3104 
operator VkSemaphore() const3105     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
3106     {
3107       return m_semaphore;
3108     }
3109 
operator bool() const3110     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3111     {
3112       return m_semaphore != VK_NULL_HANDLE;
3113     }
3114 
operator !() const3115     bool operator!() const VULKAN_HPP_NOEXCEPT
3116     {
3117       return m_semaphore == VK_NULL_HANDLE;
3118     }
3119 
3120   private:
3121     VkSemaphore m_semaphore = {};
3122   };
3123 
3124   template <>
3125   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
3126   {
3127     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
3128   };
3129 
3130   template <>
3131   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
3132   {
3133     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
3134   };
3135 
3136 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3137   template <>
3138   struct CppType<VkSemaphore, VK_NULL_HANDLE>
3139   {
3140     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
3141   };
3142 #endif
3143 
3144   template <>
3145   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
3146   {
3147     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3148   };
3149 
3150   class Fence
3151   {
3152   public:
3153     using CType      = VkFence;
3154     using NativeType = VkFence;
3155 
3156     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
3157     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3158       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
3159 
3160   public:
Fence()3161     Fence() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3162     Fence( Fence const & rhs )             = default;
3163     Fence & operator=( Fence const & rhs ) = default;
3164 
3165 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3166     Fence( Fence && rhs )             = default;
3167     Fence & operator=( Fence && rhs ) = default;
3168 #else
Fence(Fence && rhs)3169     Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} ) ) {}
3170 
operator =(Fence && rhs)3171     Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT
3172     {
3173       m_fence = VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} );
3174       return *this;
3175     }
3176 #endif
3177 
Fence(std::nullptr_t)3178     VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3179 
Fence(VkFence fence)3180     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
3181 
3182 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkFence fence)3183     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
3184     {
3185       m_fence = fence;
3186       return *this;
3187     }
3188 #endif
3189 
operator =(std::nullptr_t)3190     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3191     {
3192       m_fence = {};
3193       return *this;
3194     }
3195 
3196 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3197     auto operator<=>( Fence const & ) const = default;
3198 #else
operator ==(Fence const & rhs) const3199     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
3200     {
3201       return m_fence == rhs.m_fence;
3202     }
3203 
operator !=(Fence const & rhs) const3204     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
3205     {
3206       return m_fence != rhs.m_fence;
3207     }
3208 
operator <(Fence const & rhs) const3209     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
3210     {
3211       return m_fence < rhs.m_fence;
3212     }
3213 #endif
3214 
operator VkFence() const3215     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
3216     {
3217       return m_fence;
3218     }
3219 
operator bool() const3220     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3221     {
3222       return m_fence != VK_NULL_HANDLE;
3223     }
3224 
operator !() const3225     bool operator!() const VULKAN_HPP_NOEXCEPT
3226     {
3227       return m_fence == VK_NULL_HANDLE;
3228     }
3229 
3230   private:
3231     VkFence m_fence = {};
3232   };
3233 
3234   template <>
3235   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
3236   {
3237     using Type = VULKAN_HPP_NAMESPACE::Fence;
3238   };
3239 
3240   template <>
3241   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
3242   {
3243     using Type = VULKAN_HPP_NAMESPACE::Fence;
3244   };
3245 
3246 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3247   template <>
3248   struct CppType<VkFence, VK_NULL_HANDLE>
3249   {
3250     using Type = VULKAN_HPP_NAMESPACE::Fence;
3251   };
3252 #endif
3253 
3254   template <>
3255   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
3256   {
3257     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3258   };
3259 
3260   class PerformanceConfigurationINTEL
3261   {
3262   public:
3263     using CType      = VkPerformanceConfigurationINTEL;
3264     using NativeType = VkPerformanceConfigurationINTEL;
3265 
3266     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
3267     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3268       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3269 
3270   public:
PerformanceConfigurationINTEL()3271     PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3272     PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs )             = default;
3273     PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default;
3274 
3275 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3276     PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs )             = default;
3277     PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default;
3278 #else
PerformanceConfigurationINTEL(PerformanceConfigurationINTEL && rhs)3279     PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
3280       : m_performanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ) )
3281     {
3282     }
3283 
operator =(PerformanceConfigurationINTEL && rhs)3284     PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
3285     {
3286       m_performanceConfigurationINTEL = VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} );
3287       return *this;
3288     }
3289 #endif
3290 
PerformanceConfigurationINTEL(std::nullptr_t)3291     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3292 
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)3293     VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
3294       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
3295     {
3296     }
3297 
3298 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)3299     PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
3300     {
3301       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
3302       return *this;
3303     }
3304 #endif
3305 
operator =(std::nullptr_t)3306     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3307     {
3308       m_performanceConfigurationINTEL = {};
3309       return *this;
3310     }
3311 
3312 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3313     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
3314 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const3315     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3316     {
3317       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
3318     }
3319 
operator !=(PerformanceConfigurationINTEL const & rhs) const3320     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3321     {
3322       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
3323     }
3324 
operator <(PerformanceConfigurationINTEL const & rhs) const3325     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
3326     {
3327       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
3328     }
3329 #endif
3330 
operator VkPerformanceConfigurationINTEL() const3331     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
3332     {
3333       return m_performanceConfigurationINTEL;
3334     }
3335 
operator bool() const3336     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3337     {
3338       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
3339     }
3340 
operator !() const3341     bool operator!() const VULKAN_HPP_NOEXCEPT
3342     {
3343       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
3344     }
3345 
3346   private:
3347     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
3348   };
3349 
3350   template <>
3351   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
3352   {
3353     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
3354   };
3355 
3356 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3357   template <>
3358   struct CppType<VkPerformanceConfigurationINTEL, VK_NULL_HANDLE>
3359   {
3360     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
3361   };
3362 #endif
3363 
3364   template <>
3365   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
3366   {
3367     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3368   };
3369 
3370   class QueryPool
3371   {
3372   public:
3373     using CType      = VkQueryPool;
3374     using NativeType = VkQueryPool;
3375 
3376     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
3377     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3378       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
3379 
3380   public:
QueryPool()3381     QueryPool() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3382     QueryPool( QueryPool const & rhs )             = default;
3383     QueryPool & operator=( QueryPool const & rhs ) = default;
3384 
3385 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3386     QueryPool( QueryPool && rhs )             = default;
3387     QueryPool & operator=( QueryPool && rhs ) = default;
3388 #else
QueryPool(QueryPool && rhs)3389     QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) {}
3390 
operator =(QueryPool && rhs)3391     QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
3392     {
3393       m_queryPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} );
3394       return *this;
3395     }
3396 #endif
3397 
QueryPool(std::nullptr_t)3398     VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3399 
QueryPool(VkQueryPool queryPool)3400     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
3401 
3402 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkQueryPool queryPool)3403     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
3404     {
3405       m_queryPool = queryPool;
3406       return *this;
3407     }
3408 #endif
3409 
operator =(std::nullptr_t)3410     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3411     {
3412       m_queryPool = {};
3413       return *this;
3414     }
3415 
3416 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3417     auto operator<=>( QueryPool const & ) const = default;
3418 #else
operator ==(QueryPool const & rhs) const3419     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3420     {
3421       return m_queryPool == rhs.m_queryPool;
3422     }
3423 
operator !=(QueryPool const & rhs) const3424     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3425     {
3426       return m_queryPool != rhs.m_queryPool;
3427     }
3428 
operator <(QueryPool const & rhs) const3429     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3430     {
3431       return m_queryPool < rhs.m_queryPool;
3432     }
3433 #endif
3434 
operator VkQueryPool() const3435     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
3436     {
3437       return m_queryPool;
3438     }
3439 
operator bool() const3440     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3441     {
3442       return m_queryPool != VK_NULL_HANDLE;
3443     }
3444 
operator !() const3445     bool operator!() const VULKAN_HPP_NOEXCEPT
3446     {
3447       return m_queryPool == VK_NULL_HANDLE;
3448     }
3449 
3450   private:
3451     VkQueryPool m_queryPool = {};
3452   };
3453 
3454   template <>
3455   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
3456   {
3457     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3458   };
3459 
3460   template <>
3461   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
3462   {
3463     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3464   };
3465 
3466 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3467   template <>
3468   struct CppType<VkQueryPool, VK_NULL_HANDLE>
3469   {
3470     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3471   };
3472 #endif
3473 
3474   template <>
3475   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
3476   {
3477     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3478   };
3479 
3480   class Buffer
3481   {
3482   public:
3483     using CType      = VkBuffer;
3484     using NativeType = VkBuffer;
3485 
3486     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
3487     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3488       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
3489 
3490   public:
Buffer()3491     Buffer() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3492     Buffer( Buffer const & rhs )             = default;
3493     Buffer & operator=( Buffer const & rhs ) = default;
3494 
3495 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3496     Buffer( Buffer && rhs )             = default;
3497     Buffer & operator=( Buffer && rhs ) = default;
3498 #else
Buffer(Buffer && rhs)3499     Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} ) ) {}
3500 
operator =(Buffer && rhs)3501     Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
3502     {
3503       m_buffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} );
3504       return *this;
3505     }
3506 #endif
3507 
Buffer(std::nullptr_t)3508     VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3509 
Buffer(VkBuffer buffer)3510     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
3511 
3512 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkBuffer buffer)3513     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3514     {
3515       m_buffer = buffer;
3516       return *this;
3517     }
3518 #endif
3519 
operator =(std::nullptr_t)3520     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3521     {
3522       m_buffer = {};
3523       return *this;
3524     }
3525 
3526 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3527     auto operator<=>( Buffer const & ) const = default;
3528 #else
operator ==(Buffer const & rhs) const3529     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3530     {
3531       return m_buffer == rhs.m_buffer;
3532     }
3533 
operator !=(Buffer const & rhs) const3534     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3535     {
3536       return m_buffer != rhs.m_buffer;
3537     }
3538 
operator <(Buffer const & rhs) const3539     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3540     {
3541       return m_buffer < rhs.m_buffer;
3542     }
3543 #endif
3544 
operator VkBuffer() const3545     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
3546     {
3547       return m_buffer;
3548     }
3549 
operator bool() const3550     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3551     {
3552       return m_buffer != VK_NULL_HANDLE;
3553     }
3554 
operator !() const3555     bool operator!() const VULKAN_HPP_NOEXCEPT
3556     {
3557       return m_buffer == VK_NULL_HANDLE;
3558     }
3559 
3560   private:
3561     VkBuffer m_buffer = {};
3562   };
3563 
3564   template <>
3565   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
3566   {
3567     using Type = VULKAN_HPP_NAMESPACE::Buffer;
3568   };
3569 
3570   template <>
3571   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
3572   {
3573     using Type = VULKAN_HPP_NAMESPACE::Buffer;
3574   };
3575 
3576 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3577   template <>
3578   struct CppType<VkBuffer, VK_NULL_HANDLE>
3579   {
3580     using Type = VULKAN_HPP_NAMESPACE::Buffer;
3581   };
3582 #endif
3583 
3584   template <>
3585   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
3586   {
3587     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3588   };
3589 
3590   class PipelineLayout
3591   {
3592   public:
3593     using CType      = VkPipelineLayout;
3594     using NativeType = VkPipelineLayout;
3595 
3596     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
3597     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3598       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
3599 
3600   public:
PipelineLayout()3601     PipelineLayout() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3602     PipelineLayout( PipelineLayout const & rhs )             = default;
3603     PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
3604 
3605 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3606     PipelineLayout( PipelineLayout && rhs )             = default;
3607     PipelineLayout & operator=( PipelineLayout && rhs ) = default;
3608 #else
PipelineLayout(PipelineLayout && rhs)3609     PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) {}
3610 
operator =(PipelineLayout && rhs)3611     PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
3612     {
3613       m_pipelineLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );
3614       return *this;
3615     }
3616 #endif
3617 
PipelineLayout(std::nullptr_t)3618     VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3619 
PipelineLayout(VkPipelineLayout pipelineLayout)3620     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
3621 
3622 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipelineLayout pipelineLayout)3623     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3624     {
3625       m_pipelineLayout = pipelineLayout;
3626       return *this;
3627     }
3628 #endif
3629 
operator =(std::nullptr_t)3630     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3631     {
3632       m_pipelineLayout = {};
3633       return *this;
3634     }
3635 
3636 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3637     auto operator<=>( PipelineLayout const & ) const = default;
3638 #else
operator ==(PipelineLayout const & rhs) const3639     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3640     {
3641       return m_pipelineLayout == rhs.m_pipelineLayout;
3642     }
3643 
operator !=(PipelineLayout const & rhs) const3644     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3645     {
3646       return m_pipelineLayout != rhs.m_pipelineLayout;
3647     }
3648 
operator <(PipelineLayout const & rhs) const3649     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
3650     {
3651       return m_pipelineLayout < rhs.m_pipelineLayout;
3652     }
3653 #endif
3654 
operator VkPipelineLayout() const3655     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
3656     {
3657       return m_pipelineLayout;
3658     }
3659 
operator bool() const3660     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3661     {
3662       return m_pipelineLayout != VK_NULL_HANDLE;
3663     }
3664 
operator !() const3665     bool operator!() const VULKAN_HPP_NOEXCEPT
3666     {
3667       return m_pipelineLayout == VK_NULL_HANDLE;
3668     }
3669 
3670   private:
3671     VkPipelineLayout m_pipelineLayout = {};
3672   };
3673 
3674   template <>
3675   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
3676   {
3677     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3678   };
3679 
3680   template <>
3681   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
3682   {
3683     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3684   };
3685 
3686 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3687   template <>
3688   struct CppType<VkPipelineLayout, VK_NULL_HANDLE>
3689   {
3690     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3691   };
3692 #endif
3693 
3694   template <>
3695   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
3696   {
3697     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3698   };
3699 
3700   class DescriptorSet
3701   {
3702   public:
3703     using CType      = VkDescriptorSet;
3704     using NativeType = VkDescriptorSet;
3705 
3706     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
3707     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3708       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
3709 
3710   public:
DescriptorSet()3711     DescriptorSet() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3712     DescriptorSet( DescriptorSet const & rhs )             = default;
3713     DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
3714 
3715 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3716     DescriptorSet( DescriptorSet && rhs )             = default;
3717     DescriptorSet & operator=( DescriptorSet && rhs ) = default;
3718 #else
DescriptorSet(DescriptorSet && rhs)3719     DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) {}
3720 
operator =(DescriptorSet && rhs)3721     DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
3722     {
3723       m_descriptorSet = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} );
3724       return *this;
3725     }
3726 #endif
3727 
DescriptorSet(std::nullptr_t)3728     VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3729 
DescriptorSet(VkDescriptorSet descriptorSet)3730     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
3731 
3732 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorSet descriptorSet)3733     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
3734     {
3735       m_descriptorSet = descriptorSet;
3736       return *this;
3737     }
3738 #endif
3739 
operator =(std::nullptr_t)3740     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3741     {
3742       m_descriptorSet = {};
3743       return *this;
3744     }
3745 
3746 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3747     auto operator<=>( DescriptorSet const & ) const = default;
3748 #else
operator ==(DescriptorSet const & rhs) const3749     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3750     {
3751       return m_descriptorSet == rhs.m_descriptorSet;
3752     }
3753 
operator !=(DescriptorSet const & rhs) const3754     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3755     {
3756       return m_descriptorSet != rhs.m_descriptorSet;
3757     }
3758 
operator <(DescriptorSet const & rhs) const3759     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3760     {
3761       return m_descriptorSet < rhs.m_descriptorSet;
3762     }
3763 #endif
3764 
operator VkDescriptorSet() const3765     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
3766     {
3767       return m_descriptorSet;
3768     }
3769 
operator bool() const3770     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3771     {
3772       return m_descriptorSet != VK_NULL_HANDLE;
3773     }
3774 
operator !() const3775     bool operator!() const VULKAN_HPP_NOEXCEPT
3776     {
3777       return m_descriptorSet == VK_NULL_HANDLE;
3778     }
3779 
3780   private:
3781     VkDescriptorSet m_descriptorSet = {};
3782   };
3783 
3784   template <>
3785   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
3786   {
3787     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3788   };
3789 
3790   template <>
3791   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
3792   {
3793     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3794   };
3795 
3796 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3797   template <>
3798   struct CppType<VkDescriptorSet, VK_NULL_HANDLE>
3799   {
3800     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3801   };
3802 #endif
3803 
3804   template <>
3805   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
3806   {
3807     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3808   };
3809 
3810   class ImageView
3811   {
3812   public:
3813     using CType      = VkImageView;
3814     using NativeType = VkImageView;
3815 
3816     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
3817     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3818       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
3819 
3820   public:
ImageView()3821     ImageView() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3822     ImageView( ImageView const & rhs )             = default;
3823     ImageView & operator=( ImageView const & rhs ) = default;
3824 
3825 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3826     ImageView( ImageView && rhs )             = default;
3827     ImageView & operator=( ImageView && rhs ) = default;
3828 #else
ImageView(ImageView && rhs)3829     ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} ) ) {}
3830 
operator =(ImageView && rhs)3831     ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
3832     {
3833       m_imageView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} );
3834       return *this;
3835     }
3836 #endif
3837 
ImageView(std::nullptr_t)3838     VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3839 
ImageView(VkImageView imageView)3840     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
3841 
3842 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkImageView imageView)3843     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3844     {
3845       m_imageView = imageView;
3846       return *this;
3847     }
3848 #endif
3849 
operator =(std::nullptr_t)3850     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3851     {
3852       m_imageView = {};
3853       return *this;
3854     }
3855 
3856 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3857     auto operator<=>( ImageView const & ) const = default;
3858 #else
operator ==(ImageView const & rhs) const3859     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3860     {
3861       return m_imageView == rhs.m_imageView;
3862     }
3863 
operator !=(ImageView const & rhs) const3864     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3865     {
3866       return m_imageView != rhs.m_imageView;
3867     }
3868 
operator <(ImageView const & rhs) const3869     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3870     {
3871       return m_imageView < rhs.m_imageView;
3872     }
3873 #endif
3874 
operator VkImageView() const3875     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
3876     {
3877       return m_imageView;
3878     }
3879 
operator bool() const3880     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3881     {
3882       return m_imageView != VK_NULL_HANDLE;
3883     }
3884 
operator !() const3885     bool operator!() const VULKAN_HPP_NOEXCEPT
3886     {
3887       return m_imageView == VK_NULL_HANDLE;
3888     }
3889 
3890   private:
3891     VkImageView m_imageView = {};
3892   };
3893 
3894   template <>
3895   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
3896   {
3897     using Type = VULKAN_HPP_NAMESPACE::ImageView;
3898   };
3899 
3900   template <>
3901   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
3902   {
3903     using Type = VULKAN_HPP_NAMESPACE::ImageView;
3904   };
3905 
3906 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
3907   template <>
3908   struct CppType<VkImageView, VK_NULL_HANDLE>
3909   {
3910     using Type = VULKAN_HPP_NAMESPACE::ImageView;
3911   };
3912 #endif
3913 
3914   template <>
3915   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
3916   {
3917     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3918   };
3919 
3920   class Pipeline
3921   {
3922   public:
3923     using CType      = VkPipeline;
3924     using NativeType = VkPipeline;
3925 
3926     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
3927     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3928       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
3929 
3930   public:
Pipeline()3931     Pipeline() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
3932     Pipeline( Pipeline const & rhs )             = default;
3933     Pipeline & operator=( Pipeline const & rhs ) = default;
3934 
3935 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
3936     Pipeline( Pipeline && rhs )             = default;
3937     Pipeline & operator=( Pipeline && rhs ) = default;
3938 #else
Pipeline(Pipeline && rhs)3939     Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) {}
3940 
operator =(Pipeline && rhs)3941     Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
3942     {
3943       m_pipeline = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} );
3944       return *this;
3945     }
3946 #endif
3947 
Pipeline(std::nullptr_t)3948     VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3949 
Pipeline(VkPipeline pipeline)3950     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
3951 
3952 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipeline pipeline)3953     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
3954     {
3955       m_pipeline = pipeline;
3956       return *this;
3957     }
3958 #endif
3959 
operator =(std::nullptr_t)3960     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3961     {
3962       m_pipeline = {};
3963       return *this;
3964     }
3965 
3966 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3967     auto operator<=>( Pipeline const & ) const = default;
3968 #else
operator ==(Pipeline const & rhs) const3969     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3970     {
3971       return m_pipeline == rhs.m_pipeline;
3972     }
3973 
operator !=(Pipeline const & rhs) const3974     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3975     {
3976       return m_pipeline != rhs.m_pipeline;
3977     }
3978 
operator <(Pipeline const & rhs) const3979     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3980     {
3981       return m_pipeline < rhs.m_pipeline;
3982     }
3983 #endif
3984 
operator VkPipeline() const3985     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
3986     {
3987       return m_pipeline;
3988     }
3989 
operator bool() const3990     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3991     {
3992       return m_pipeline != VK_NULL_HANDLE;
3993     }
3994 
operator !() const3995     bool operator!() const VULKAN_HPP_NOEXCEPT
3996     {
3997       return m_pipeline == VK_NULL_HANDLE;
3998     }
3999 
4000   private:
4001     VkPipeline m_pipeline = {};
4002   };
4003 
4004   template <>
4005   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
4006   {
4007     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
4008   };
4009 
4010   template <>
4011   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
4012   {
4013     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
4014   };
4015 
4016 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4017   template <>
4018   struct CppType<VkPipeline, VK_NULL_HANDLE>
4019   {
4020     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
4021   };
4022 #endif
4023 
4024   template <>
4025   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
4026   {
4027     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4028   };
4029 
4030   class ShaderEXT
4031   {
4032   public:
4033     using CType      = VkShaderEXT;
4034     using NativeType = VkShaderEXT;
4035 
4036     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
4037     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4038       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4039 
4040   public:
ShaderEXT()4041     ShaderEXT() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4042     ShaderEXT( ShaderEXT const & rhs )             = default;
4043     ShaderEXT & operator=( ShaderEXT const & rhs ) = default;
4044 
4045 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4046     ShaderEXT( ShaderEXT && rhs )             = default;
4047     ShaderEXT & operator=( ShaderEXT && rhs ) = default;
4048 #else
ShaderEXT(ShaderEXT && rhs)4049     ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} ) ) {}
4050 
operator =(ShaderEXT && rhs)4051     ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT
4052     {
4053       m_shaderEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} );
4054       return *this;
4055     }
4056 #endif
4057 
ShaderEXT(std::nullptr_t)4058     VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4059 
ShaderEXT(VkShaderEXT shaderEXT)4060     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
4061 
4062 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkShaderEXT shaderEXT)4063     ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
4064     {
4065       m_shaderEXT = shaderEXT;
4066       return *this;
4067     }
4068 #endif
4069 
operator =(std::nullptr_t)4070     ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4071     {
4072       m_shaderEXT = {};
4073       return *this;
4074     }
4075 
4076 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4077     auto operator<=>( ShaderEXT const & ) const = default;
4078 #else
operator ==(ShaderEXT const & rhs) const4079     bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4080     {
4081       return m_shaderEXT == rhs.m_shaderEXT;
4082     }
4083 
operator !=(ShaderEXT const & rhs) const4084     bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4085     {
4086       return m_shaderEXT != rhs.m_shaderEXT;
4087     }
4088 
operator <(ShaderEXT const & rhs) const4089     bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4090     {
4091       return m_shaderEXT < rhs.m_shaderEXT;
4092     }
4093 #endif
4094 
operator VkShaderEXT() const4095     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT
4096     {
4097       return m_shaderEXT;
4098     }
4099 
operator bool() const4100     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4101     {
4102       return m_shaderEXT != VK_NULL_HANDLE;
4103     }
4104 
operator !() const4105     bool operator!() const VULKAN_HPP_NOEXCEPT
4106     {
4107       return m_shaderEXT == VK_NULL_HANDLE;
4108     }
4109 
4110   private:
4111     VkShaderEXT m_shaderEXT = {};
4112   };
4113 
4114   template <>
4115   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>
4116   {
4117     using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
4118   };
4119 
4120 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4121   template <>
4122   struct CppType<VkShaderEXT, VK_NULL_HANDLE>
4123   {
4124     using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
4125   };
4126 #endif
4127 
4128   template <>
4129   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>
4130   {
4131     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4132   };
4133 
4134   class Image
4135   {
4136   public:
4137     using CType      = VkImage;
4138     using NativeType = VkImage;
4139 
4140     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
4141     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4142       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
4143 
4144   public:
Image()4145     Image() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4146     Image( Image const & rhs )             = default;
4147     Image & operator=( Image const & rhs ) = default;
4148 
4149 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4150     Image( Image && rhs )             = default;
4151     Image & operator=( Image && rhs ) = default;
4152 #else
Image(Image && rhs)4153     Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} ) ) {}
4154 
operator =(Image && rhs)4155     Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
4156     {
4157       m_image = VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} );
4158       return *this;
4159     }
4160 #endif
4161 
Image(std::nullptr_t)4162     VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4163 
Image(VkImage image)4164     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
4165 
4166 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkImage image)4167     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
4168     {
4169       m_image = image;
4170       return *this;
4171     }
4172 #endif
4173 
operator =(std::nullptr_t)4174     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4175     {
4176       m_image = {};
4177       return *this;
4178     }
4179 
4180 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4181     auto operator<=>( Image const & ) const = default;
4182 #else
operator ==(Image const & rhs) const4183     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
4184     {
4185       return m_image == rhs.m_image;
4186     }
4187 
operator !=(Image const & rhs) const4188     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
4189     {
4190       return m_image != rhs.m_image;
4191     }
4192 
operator <(Image const & rhs) const4193     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
4194     {
4195       return m_image < rhs.m_image;
4196     }
4197 #endif
4198 
operator VkImage() const4199     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
4200     {
4201       return m_image;
4202     }
4203 
operator bool() const4204     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4205     {
4206       return m_image != VK_NULL_HANDLE;
4207     }
4208 
operator !() const4209     bool operator!() const VULKAN_HPP_NOEXCEPT
4210     {
4211       return m_image == VK_NULL_HANDLE;
4212     }
4213 
4214   private:
4215     VkImage m_image = {};
4216   };
4217 
4218   template <>
4219   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
4220   {
4221     using Type = VULKAN_HPP_NAMESPACE::Image;
4222   };
4223 
4224   template <>
4225   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
4226   {
4227     using Type = VULKAN_HPP_NAMESPACE::Image;
4228   };
4229 
4230 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4231   template <>
4232   struct CppType<VkImage, VK_NULL_HANDLE>
4233   {
4234     using Type = VULKAN_HPP_NAMESPACE::Image;
4235   };
4236 #endif
4237 
4238   template <>
4239   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
4240   {
4241     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4242   };
4243 
4244   class AccelerationStructureNV
4245   {
4246   public:
4247     using CType      = VkAccelerationStructureNV;
4248     using NativeType = VkAccelerationStructureNV;
4249 
4250     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
4251     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4252       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
4253 
4254   public:
AccelerationStructureNV()4255     AccelerationStructureNV() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4256     AccelerationStructureNV( AccelerationStructureNV const & rhs )             = default;
4257     AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default;
4258 
4259 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4260     AccelerationStructureNV( AccelerationStructureNV && rhs )             = default;
4261     AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default;
4262 #else
AccelerationStructureNV(AccelerationStructureNV && rhs)4263     AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
4264       : m_accelerationStructureNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ) )
4265     {
4266     }
4267 
operator =(AccelerationStructureNV && rhs)4268     AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
4269     {
4270       m_accelerationStructureNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} );
4271       return *this;
4272     }
4273 #endif
4274 
AccelerationStructureNV(std::nullptr_t)4275     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4276 
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)4277     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
4278       : m_accelerationStructureNV( accelerationStructureNV )
4279     {
4280     }
4281 
4282 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkAccelerationStructureNV accelerationStructureNV)4283     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
4284     {
4285       m_accelerationStructureNV = accelerationStructureNV;
4286       return *this;
4287     }
4288 #endif
4289 
operator =(std::nullptr_t)4290     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4291     {
4292       m_accelerationStructureNV = {};
4293       return *this;
4294     }
4295 
4296 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4297     auto operator<=>( AccelerationStructureNV const & ) const = default;
4298 #else
operator ==(AccelerationStructureNV const & rhs) const4299     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4300     {
4301       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
4302     }
4303 
operator !=(AccelerationStructureNV const & rhs) const4304     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4305     {
4306       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
4307     }
4308 
operator <(AccelerationStructureNV const & rhs) const4309     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4310     {
4311       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
4312     }
4313 #endif
4314 
operator VkAccelerationStructureNV() const4315     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
4316     {
4317       return m_accelerationStructureNV;
4318     }
4319 
operator bool() const4320     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4321     {
4322       return m_accelerationStructureNV != VK_NULL_HANDLE;
4323     }
4324 
operator !() const4325     bool operator!() const VULKAN_HPP_NOEXCEPT
4326     {
4327       return m_accelerationStructureNV == VK_NULL_HANDLE;
4328     }
4329 
4330   private:
4331     VkAccelerationStructureNV m_accelerationStructureNV = {};
4332   };
4333 
4334   template <>
4335   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
4336   {
4337     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
4338   };
4339 
4340   template <>
4341   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
4342   {
4343     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
4344   };
4345 
4346 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4347   template <>
4348   struct CppType<VkAccelerationStructureNV, VK_NULL_HANDLE>
4349   {
4350     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
4351   };
4352 #endif
4353 
4354   template <>
4355   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
4356   {
4357     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4358   };
4359 
4360   class OpticalFlowSessionNV
4361   {
4362   public:
4363     using CType      = VkOpticalFlowSessionNV;
4364     using NativeType = VkOpticalFlowSessionNV;
4365 
4366     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
4367     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4368       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4369 
4370   public:
OpticalFlowSessionNV()4371     OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4372     OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs )             = default;
4373     OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default;
4374 
4375 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4376     OpticalFlowSessionNV( OpticalFlowSessionNV && rhs )             = default;
4377     OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default;
4378 #else
OpticalFlowSessionNV(OpticalFlowSessionNV && rhs)4379     OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
4380       : m_opticalFlowSessionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} ) )
4381     {
4382     }
4383 
operator =(OpticalFlowSessionNV && rhs)4384     OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
4385     {
4386       m_opticalFlowSessionNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} );
4387       return *this;
4388     }
4389 #endif
4390 
OpticalFlowSessionNV(std::nullptr_t)4391     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4392 
OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV)4393     VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
4394       : m_opticalFlowSessionNV( opticalFlowSessionNV )
4395     {
4396     }
4397 
4398 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkOpticalFlowSessionNV opticalFlowSessionNV)4399     OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
4400     {
4401       m_opticalFlowSessionNV = opticalFlowSessionNV;
4402       return *this;
4403     }
4404 #endif
4405 
operator =(std::nullptr_t)4406     OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4407     {
4408       m_opticalFlowSessionNV = {};
4409       return *this;
4410     }
4411 
4412 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4413     auto operator<=>( OpticalFlowSessionNV const & ) const = default;
4414 #else
operator ==(OpticalFlowSessionNV const & rhs) const4415     bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4416     {
4417       return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
4418     }
4419 
operator !=(OpticalFlowSessionNV const & rhs) const4420     bool operator!=( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4421     {
4422       return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
4423     }
4424 
operator <(OpticalFlowSessionNV const & rhs) const4425     bool operator<( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
4426     {
4427       return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
4428     }
4429 #endif
4430 
operator VkOpticalFlowSessionNV() const4431     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
4432     {
4433       return m_opticalFlowSessionNV;
4434     }
4435 
operator bool() const4436     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4437     {
4438       return m_opticalFlowSessionNV != VK_NULL_HANDLE;
4439     }
4440 
operator !() const4441     bool operator!() const VULKAN_HPP_NOEXCEPT
4442     {
4443       return m_opticalFlowSessionNV == VK_NULL_HANDLE;
4444     }
4445 
4446   private:
4447     VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
4448   };
4449 
4450   template <>
4451   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>
4452   {
4453     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
4454   };
4455 
4456 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4457   template <>
4458   struct CppType<VkOpticalFlowSessionNV, VK_NULL_HANDLE>
4459   {
4460     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
4461   };
4462 #endif
4463 
4464   template <>
4465   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
4466   {
4467     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4468   };
4469 
4470   class DescriptorUpdateTemplate
4471   {
4472   public:
4473     using CType      = VkDescriptorUpdateTemplate;
4474     using NativeType = VkDescriptorUpdateTemplate;
4475 
4476     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
4477     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4478       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
4479 
4480   public:
DescriptorUpdateTemplate()4481     DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4482     DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs )             = default;
4483     DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default;
4484 
4485 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4486     DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs )             = default;
4487     DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default;
4488 #else
DescriptorUpdateTemplate(DescriptorUpdateTemplate && rhs)4489     DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
4490       : m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) )
4491     {
4492     }
4493 
operator =(DescriptorUpdateTemplate && rhs)4494     DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
4495     {
4496       m_descriptorUpdateTemplate = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} );
4497       return *this;
4498     }
4499 #endif
4500 
DescriptorUpdateTemplate(std::nullptr_t)4501     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4502 
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)4503     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
4504       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
4505     {
4506     }
4507 
4508 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)4509     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
4510     {
4511       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
4512       return *this;
4513     }
4514 #endif
4515 
operator =(std::nullptr_t)4516     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4517     {
4518       m_descriptorUpdateTemplate = {};
4519       return *this;
4520     }
4521 
4522 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4523     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
4524 #else
operator ==(DescriptorUpdateTemplate const & rhs) const4525     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
4526     {
4527       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
4528     }
4529 
operator !=(DescriptorUpdateTemplate const & rhs) const4530     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
4531     {
4532       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
4533     }
4534 
operator <(DescriptorUpdateTemplate const & rhs) const4535     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
4536     {
4537       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
4538     }
4539 #endif
4540 
operator VkDescriptorUpdateTemplate() const4541     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
4542     {
4543       return m_descriptorUpdateTemplate;
4544     }
4545 
operator bool() const4546     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4547     {
4548       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
4549     }
4550 
operator !() const4551     bool operator!() const VULKAN_HPP_NOEXCEPT
4552     {
4553       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
4554     }
4555 
4556   private:
4557     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
4558   };
4559 
4560   template <>
4561   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
4562   {
4563     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
4564   };
4565 
4566   template <>
4567   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
4568   {
4569     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
4570   };
4571 
4572 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4573   template <>
4574   struct CppType<VkDescriptorUpdateTemplate, VK_NULL_HANDLE>
4575   {
4576     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
4577   };
4578 #endif
4579 
4580   template <>
4581   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
4582   {
4583     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4584   };
4585 
4586   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
4587 
4588   class Event
4589   {
4590   public:
4591     using CType      = VkEvent;
4592     using NativeType = VkEvent;
4593 
4594     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
4595     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4596       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
4597 
4598   public:
Event()4599     Event() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4600     Event( Event const & rhs )             = default;
4601     Event & operator=( Event const & rhs ) = default;
4602 
4603 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4604     Event( Event && rhs )             = default;
4605     Event & operator=( Event && rhs ) = default;
4606 #else
Event(Event && rhs)4607     Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} ) ) {}
4608 
operator =(Event && rhs)4609     Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT
4610     {
4611       m_event = VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} );
4612       return *this;
4613     }
4614 #endif
4615 
Event(std::nullptr_t)4616     VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4617 
Event(VkEvent event)4618     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
4619 
4620 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkEvent event)4621     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
4622     {
4623       m_event = event;
4624       return *this;
4625     }
4626 #endif
4627 
operator =(std::nullptr_t)4628     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4629     {
4630       m_event = {};
4631       return *this;
4632     }
4633 
4634 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4635     auto operator<=>( Event const & ) const = default;
4636 #else
operator ==(Event const & rhs) const4637     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4638     {
4639       return m_event == rhs.m_event;
4640     }
4641 
operator !=(Event const & rhs) const4642     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4643     {
4644       return m_event != rhs.m_event;
4645     }
4646 
operator <(Event const & rhs) const4647     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4648     {
4649       return m_event < rhs.m_event;
4650     }
4651 #endif
4652 
operator VkEvent() const4653     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
4654     {
4655       return m_event;
4656     }
4657 
operator bool() const4658     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4659     {
4660       return m_event != VK_NULL_HANDLE;
4661     }
4662 
operator !() const4663     bool operator!() const VULKAN_HPP_NOEXCEPT
4664     {
4665       return m_event == VK_NULL_HANDLE;
4666     }
4667 
4668   private:
4669     VkEvent m_event = {};
4670   };
4671 
4672   template <>
4673   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
4674   {
4675     using Type = VULKAN_HPP_NAMESPACE::Event;
4676   };
4677 
4678   template <>
4679   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
4680   {
4681     using Type = VULKAN_HPP_NAMESPACE::Event;
4682   };
4683 
4684 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4685   template <>
4686   struct CppType<VkEvent, VK_NULL_HANDLE>
4687   {
4688     using Type = VULKAN_HPP_NAMESPACE::Event;
4689   };
4690 #endif
4691 
4692   template <>
4693   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
4694   {
4695     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4696   };
4697 
4698   class AccelerationStructureKHR
4699   {
4700   public:
4701     using CType      = VkAccelerationStructureKHR;
4702     using NativeType = VkAccelerationStructureKHR;
4703 
4704     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
4705     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4706       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
4707 
4708   public:
AccelerationStructureKHR()4709     AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4710     AccelerationStructureKHR( AccelerationStructureKHR const & rhs )             = default;
4711     AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default;
4712 
4713 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4714     AccelerationStructureKHR( AccelerationStructureKHR && rhs )             = default;
4715     AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default;
4716 #else
AccelerationStructureKHR(AccelerationStructureKHR && rhs)4717     AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
4718       : m_accelerationStructureKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ) )
4719     {
4720     }
4721 
operator =(AccelerationStructureKHR && rhs)4722     AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
4723     {
4724       m_accelerationStructureKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} );
4725       return *this;
4726     }
4727 #endif
4728 
AccelerationStructureKHR(std::nullptr_t)4729     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4730 
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)4731     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4732       : m_accelerationStructureKHR( accelerationStructureKHR )
4733     {
4734     }
4735 
4736 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkAccelerationStructureKHR accelerationStructureKHR)4737     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4738     {
4739       m_accelerationStructureKHR = accelerationStructureKHR;
4740       return *this;
4741     }
4742 #endif
4743 
operator =(std::nullptr_t)4744     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4745     {
4746       m_accelerationStructureKHR = {};
4747       return *this;
4748     }
4749 
4750 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4751     auto operator<=>( AccelerationStructureKHR const & ) const = default;
4752 #else
operator ==(AccelerationStructureKHR const & rhs) const4753     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4754     {
4755       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
4756     }
4757 
operator !=(AccelerationStructureKHR const & rhs) const4758     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4759     {
4760       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
4761     }
4762 
operator <(AccelerationStructureKHR const & rhs) const4763     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4764     {
4765       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
4766     }
4767 #endif
4768 
operator VkAccelerationStructureKHR() const4769     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4770     {
4771       return m_accelerationStructureKHR;
4772     }
4773 
operator bool() const4774     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4775     {
4776       return m_accelerationStructureKHR != VK_NULL_HANDLE;
4777     }
4778 
operator !() const4779     bool operator!() const VULKAN_HPP_NOEXCEPT
4780     {
4781       return m_accelerationStructureKHR == VK_NULL_HANDLE;
4782     }
4783 
4784   private:
4785     VkAccelerationStructureKHR m_accelerationStructureKHR = {};
4786   };
4787 
4788   template <>
4789   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
4790   {
4791     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4792   };
4793 
4794   template <>
4795   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
4796   {
4797     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4798   };
4799 
4800 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4801   template <>
4802   struct CppType<VkAccelerationStructureKHR, VK_NULL_HANDLE>
4803   {
4804     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4805   };
4806 #endif
4807 
4808   template <>
4809   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
4810   {
4811     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4812   };
4813 
4814   class MicromapEXT
4815   {
4816   public:
4817     using CType      = VkMicromapEXT;
4818     using NativeType = VkMicromapEXT;
4819 
4820     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
4821     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4822       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4823 
4824   public:
MicromapEXT()4825     MicromapEXT() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4826     MicromapEXT( MicromapEXT const & rhs )             = default;
4827     MicromapEXT & operator=( MicromapEXT const & rhs ) = default;
4828 
4829 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4830     MicromapEXT( MicromapEXT && rhs )             = default;
4831     MicromapEXT & operator=( MicromapEXT && rhs ) = default;
4832 #else
MicromapEXT(MicromapEXT && rhs)4833     MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} ) ) {}
4834 
operator =(MicromapEXT && rhs)4835     MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT
4836     {
4837       m_micromapEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} );
4838       return *this;
4839     }
4840 #endif
4841 
MicromapEXT(std::nullptr_t)4842     VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4843 
MicromapEXT(VkMicromapEXT micromapEXT)4844     VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
4845 
4846 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkMicromapEXT micromapEXT)4847     MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
4848     {
4849       m_micromapEXT = micromapEXT;
4850       return *this;
4851     }
4852 #endif
4853 
operator =(std::nullptr_t)4854     MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4855     {
4856       m_micromapEXT = {};
4857       return *this;
4858     }
4859 
4860 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4861     auto operator<=>( MicromapEXT const & ) const = default;
4862 #else
operator ==(MicromapEXT const & rhs) const4863     bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4864     {
4865       return m_micromapEXT == rhs.m_micromapEXT;
4866     }
4867 
operator !=(MicromapEXT const & rhs) const4868     bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4869     {
4870       return m_micromapEXT != rhs.m_micromapEXT;
4871     }
4872 
operator <(MicromapEXT const & rhs) const4873     bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4874     {
4875       return m_micromapEXT < rhs.m_micromapEXT;
4876     }
4877 #endif
4878 
operator VkMicromapEXT() const4879     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
4880     {
4881       return m_micromapEXT;
4882     }
4883 
operator bool() const4884     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4885     {
4886       return m_micromapEXT != VK_NULL_HANDLE;
4887     }
4888 
operator !() const4889     bool operator!() const VULKAN_HPP_NOEXCEPT
4890     {
4891       return m_micromapEXT == VK_NULL_HANDLE;
4892     }
4893 
4894   private:
4895     VkMicromapEXT m_micromapEXT = {};
4896   };
4897 
4898   template <>
4899   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>
4900   {
4901     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4902   };
4903 
4904 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
4905   template <>
4906   struct CppType<VkMicromapEXT, VK_NULL_HANDLE>
4907   {
4908     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4909   };
4910 #endif
4911 
4912   template <>
4913   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>
4914   {
4915     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4916   };
4917 
4918   class CommandBuffer
4919   {
4920   public:
4921     using CType      = VkCommandBuffer;
4922     using NativeType = VkCommandBuffer;
4923 
4924     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
4925     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4926       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
4927 
4928   public:
CommandBuffer()4929     CommandBuffer() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
4930     CommandBuffer( CommandBuffer const & rhs )             = default;
4931     CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
4932 
4933 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
4934     CommandBuffer( CommandBuffer && rhs )             = default;
4935     CommandBuffer & operator=( CommandBuffer && rhs ) = default;
4936 #else
CommandBuffer(CommandBuffer && rhs)4937     CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) {}
4938 
operator =(CommandBuffer && rhs)4939     CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
4940     {
4941       m_commandBuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} );
4942       return *this;
4943     }
4944 #endif
4945 
CommandBuffer(std::nullptr_t)4946     VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
4947 
CommandBuffer(VkCommandBuffer commandBuffer)4948     CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
4949 
operator =(VkCommandBuffer commandBuffer)4950     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
4951     {
4952       m_commandBuffer = commandBuffer;
4953       return *this;
4954     }
4955 
operator =(std::nullptr_t)4956     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4957     {
4958       m_commandBuffer = {};
4959       return *this;
4960     }
4961 
4962 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4963     auto operator<=>( CommandBuffer const & ) const = default;
4964 #else
operator ==(CommandBuffer const & rhs) const4965     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4966     {
4967       return m_commandBuffer == rhs.m_commandBuffer;
4968     }
4969 
operator !=(CommandBuffer const & rhs) const4970     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4971     {
4972       return m_commandBuffer != rhs.m_commandBuffer;
4973     }
4974 
operator <(CommandBuffer const & rhs) const4975     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4976     {
4977       return m_commandBuffer < rhs.m_commandBuffer;
4978     }
4979 #endif
4980 
4981     //=== VK_VERSION_1_0 ===
4982 
4983     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4984     VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
4985                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4986 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4987     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4988     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,
4989                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4990 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4991 
4992 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4994     VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4995 #else
4996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4997     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4998 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4999 
5000 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
5001     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5002     VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
5003                                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5004 #else
5005     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5006     typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
5007                                                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5008 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
5009 
5010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5011     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5012                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
5013                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5014 
5015     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5016     void setViewport( uint32_t                               firstViewport,
5017                       uint32_t                               viewportCount,
5018                       const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
5019                       Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5022     void setViewport( uint32_t                                                                       firstViewport,
5023                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
5024                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5025 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5026 
5027     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5028     void setScissor( uint32_t                             firstScissor,
5029                      uint32_t                             scissorCount,
5030                      const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
5031                      Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5032 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5034     void setScissor( uint32_t                                                                     firstScissor,
5035                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
5036                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5037 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5038 
5039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5040     void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5041 
5042     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5043     void setDepthBias( float              depthBiasConstantFactor,
5044                        float              depthBiasClamp,
5045                        float              depthBiasSlopeFactor,
5046                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5047 
5048     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5049     void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5050 
5051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5052     void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5053 
5054     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5055     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5056                                 uint32_t                               compareMask,
5057                                 Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5058 
5059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5060     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5061                               uint32_t                               writeMask,
5062                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5063 
5064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5065     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5066                               uint32_t                               reference,
5067                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5068 
5069     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5070     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
5071                              VULKAN_HPP_NAMESPACE::PipelineLayout        layout,
5072                              uint32_t                                    firstSet,
5073                              uint32_t                                    descriptorSetCount,
5074                              const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
5075                              uint32_t                                    dynamicOffsetCount,
5076                              const uint32_t *                            pDynamicOffsets,
5077                              Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5080     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                             pipelineBindPoint,
5081                              VULKAN_HPP_NAMESPACE::PipelineLayout                                                layout,
5082                              uint32_t                                                                            firstSet,
5083                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
5084                              VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                            dynamicOffsets,
5085                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5086 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5087 
5088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5089     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5090                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
5091                           VULKAN_HPP_NAMESPACE::IndexType  indexType,
5092                           Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5093 
5094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5095     void bindVertexBuffers( uint32_t                                 firstBinding,
5096                             uint32_t                                 bindingCount,
5097                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5098                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5099                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5102     void bindVertexBuffers( uint32_t                                                                         firstBinding,
5103                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
5104                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5105                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5106 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5107 
5108     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5109     void draw( uint32_t           vertexCount,
5110                uint32_t           instanceCount,
5111                uint32_t           firstVertex,
5112                uint32_t           firstInstance,
5113                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5114 
5115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5116     void drawIndexed( uint32_t           indexCount,
5117                       uint32_t           instanceCount,
5118                       uint32_t           firstIndex,
5119                       int32_t            vertexOffset,
5120                       uint32_t           firstInstance,
5121                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5122 
5123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5124     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5125                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
5126                        uint32_t                         drawCount,
5127                        uint32_t                         stride,
5128                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5129 
5130     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5131     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5132                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
5133                               uint32_t                         drawCount,
5134                               uint32_t                         stride,
5135                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5136 
5137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5138     void dispatch( uint32_t           groupCountX,
5139                    uint32_t           groupCountY,
5140                    uint32_t           groupCountZ,
5141                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5142 
5143     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5144     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5145                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
5146                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5147 
5148     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5149     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
5150                      VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
5151                      uint32_t                                 regionCount,
5152                      const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
5153                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5156     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                                                     srcBuffer,
5157                      VULKAN_HPP_NAMESPACE::Buffer                                                     dstBuffer,
5158                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
5159                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5160 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5161 
5162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5163     void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
5164                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
5165                     VULKAN_HPP_NAMESPACE::Image             dstImage,
5166                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
5167                     uint32_t                                regionCount,
5168                     const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
5169                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5172     void copyImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,
5173                     VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,
5174                     VULKAN_HPP_NAMESPACE::Image                                                     dstImage,
5175                     VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,
5176                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
5177                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5178 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5179 
5180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5181     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
5182                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
5183                     VULKAN_HPP_NAMESPACE::Image             dstImage,
5184                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
5185                     uint32_t                                regionCount,
5186                     const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
5187                     VULKAN_HPP_NAMESPACE::Filter            filter,
5188                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5189 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5191     void blitImage( VULKAN_HPP_NAMESPACE::Image                                                     srcImage,
5192                     VULKAN_HPP_NAMESPACE::ImageLayout                                               srcImageLayout,
5193                     VULKAN_HPP_NAMESPACE::Image                                                     dstImage,
5194                     VULKAN_HPP_NAMESPACE::ImageLayout                                               dstImageLayout,
5195                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
5196                     VULKAN_HPP_NAMESPACE::Filter                                                    filter,
5197                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5198 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5199 
5200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5201     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
5202                             VULKAN_HPP_NAMESPACE::Image                   dstImage,
5203                             VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
5204                             uint32_t                                      regionCount,
5205                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
5206                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5207 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5208     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5209     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                                          srcBuffer,
5210                             VULKAN_HPP_NAMESPACE::Image                                                           dstImage,
5211                             VULKAN_HPP_NAMESPACE::ImageLayout                                                     dstImageLayout,
5212                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
5213                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5214 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5215 
5216     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5217     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
5218                             VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
5219                             VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
5220                             uint32_t                                      regionCount,
5221                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
5222                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5223 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5225     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                                           srcImage,
5226                             VULKAN_HPP_NAMESPACE::ImageLayout                                                     srcImageLayout,
5227                             VULKAN_HPP_NAMESPACE::Buffer                                                          dstBuffer,
5228                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
5229                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5230 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5231 
5232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5233     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
5234                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
5235                        VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
5236                        const void *                     pData,
5237                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5238 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5239     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5240     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer                             dstBuffer,
5241                        VULKAN_HPP_NAMESPACE::DeviceSize                         dstOffset,
5242                        VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data,
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 fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
5248                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
5249                      VULKAN_HPP_NAMESPACE::DeviceSize size,
5250                      uint32_t                         data,
5251                      Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5252 
5253     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5254     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
5255                           VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,
5256                           const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,
5257                           uint32_t                                            rangeCount,
5258                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
5259                           Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5260 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5261     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5262     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,
5263                           VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,
5264                           const VULKAN_HPP_NAMESPACE::ClearColorValue &                                               color,
5265                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
5266                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5267 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5268 
5269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5270     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
5271                                  VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
5272                                  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
5273                                  uint32_t                                             rangeCount,
5274                                  const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
5275                                  Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5278     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                                                 image,
5279                                  VULKAN_HPP_NAMESPACE::ImageLayout                                                           imageLayout,
5280                                  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &                                        depthStencil,
5281                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
5282                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5283 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5284 
5285     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5286     void clearAttachments( uint32_t                                      attachmentCount,
5287                            const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
5288                            uint32_t                                      rectCount,
5289                            const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
5290                            Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5291 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5293     void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
5294                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
5295                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5296 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5297 
5298     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5299     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
5300                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
5301                        VULKAN_HPP_NAMESPACE::Image                dstImage,
5302                        VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
5303                        uint32_t                                   regionCount,
5304                        const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
5305                        Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5307     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5308     void resolveImage( VULKAN_HPP_NAMESPACE::Image                                                        srcImage,
5309                        VULKAN_HPP_NAMESPACE::ImageLayout                                                  srcImageLayout,
5310                        VULKAN_HPP_NAMESPACE::Image                                                        dstImage,
5311                        VULKAN_HPP_NAMESPACE::ImageLayout                                                  dstImageLayout,
5312                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
5313                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5314 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5315 
5316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5317     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
5318                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
5319                    Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5320 
5321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5322     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
5323                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
5324                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5325 
5326     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5327     void waitEvents( uint32_t                                          eventCount,
5328                      const VULKAN_HPP_NAMESPACE::Event *               pEvents,
5329                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
5330                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
5331                      uint32_t                                          memoryBarrierCount,
5332                      const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
5333                      uint32_t                                          bufferMemoryBarrierCount,
5334                      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
5335                      uint32_t                                          imageMemoryBarrierCount,
5336                      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
5337                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5338 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5340     void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
5341                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,
5342                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,
5343                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
5344                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
5345                      VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
5346                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5348 
5349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5350     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
5351                           VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
5352                           VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
5353                           uint32_t                                          memoryBarrierCount,
5354                           const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
5355                           uint32_t                                          bufferMemoryBarrierCount,
5356                           const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
5357                           uint32_t                                          imageMemoryBarrierCount,
5358                           const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
5359                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5361     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5362     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  srcStageMask,
5363                           VULKAN_HPP_NAMESPACE::PipelineStageFlags                                                  dstStageMask,
5364                           VULKAN_HPP_NAMESPACE::DependencyFlags                                                     dependencyFlags,
5365                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
5366                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
5367                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
5368                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5370 
5371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5372     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
5373                      uint32_t                                query,
5374                      VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
5375                      Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5376 
5377     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5378     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5379                    uint32_t                        query,
5380                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5381 
5382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5383     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5384                          uint32_t                        firstQuery,
5385                          uint32_t                        queryCount,
5386                          Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5387 
5388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5389     void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5390                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
5391                          uint32_t                                    query,
5392                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5393 
5394     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5395     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
5396                                uint32_t                               firstQuery,
5397                                uint32_t                               queryCount,
5398                                VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
5399                                VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
5400                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
5401                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
5402                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5403 
5404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5405     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
5406                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
5407                         uint32_t                               offset,
5408                         uint32_t                               size,
5409                         const void *                           pValues,
5410                         Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5411 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5412     template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5413     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout                       layout,
5414                         VULKAN_HPP_NAMESPACE::ShaderStageFlags                     stageFlags,
5415                         uint32_t                                                   offset,
5416                         VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values,
5417                         Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5418 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5419 
5420     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5421     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5422                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
5423                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5425     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5426     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5427                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
5428                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5429 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5430 
5431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5432     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5433 
5434     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5435     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5436 
5437     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5438     void executeCommands( uint32_t                                    commandBufferCount,
5439                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
5440                           Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5441 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5443     void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
5444                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5446 
5447     //=== VK_VERSION_1_1 ===
5448 
5449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5450     void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5451 
5452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5453     void dispatchBase( uint32_t           baseGroupX,
5454                        uint32_t           baseGroupY,
5455                        uint32_t           baseGroupZ,
5456                        uint32_t           groupCountX,
5457                        uint32_t           groupCountY,
5458                        uint32_t           groupCountZ,
5459                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5460 
5461     //=== VK_VERSION_1_2 ===
5462 
5463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5464     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5465                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
5466                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5467                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5468                             uint32_t                         maxDrawCount,
5469                             uint32_t                         stride,
5470                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5471 
5472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5473     void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5474                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
5475                                    VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5476                                    VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5477                                    uint32_t                         maxDrawCount,
5478                                    uint32_t                         stride,
5479                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5480 
5481     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5482     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5483                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
5484                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5485 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5487     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5488                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
5489                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5490 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5491 
5492     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5493     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
5494                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
5495                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5498     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5499                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
5500                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5501 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5502 
5503     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5504     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
5505                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5506 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5507     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5508     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
5509                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5511 
5512     //=== VK_VERSION_1_3 ===
5513 
5514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5515     void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,
5516                     const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5517                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5518 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5519     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5520     void setEvent2( VULKAN_HPP_NAMESPACE::Event                  event,
5521                     const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5522                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5523 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5524 
5525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5526     void resetEvent2( VULKAN_HPP_NAMESPACE::Event               event,
5527                       VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,
5528                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5529 
5530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5531     void waitEvents2( uint32_t                                     eventCount,
5532                       const VULKAN_HPP_NAMESPACE::Event *          pEvents,
5533                       const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
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 waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,
5538                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
5539                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5540 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5541 
5542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5543     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5544                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5545 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5547     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5548                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5549 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5550 
5551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5552     void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
5553                           VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
5554                           uint32_t                                  query,
5555                           Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5556 
5557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5558     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
5559                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5560 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5562     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
5563                       Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5564 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5565 
5566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5567     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
5568                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5569 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5571     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
5572                      Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5574 
5575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5576     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
5577                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5578 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5580     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
5581                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5582 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5583 
5584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5585     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
5586                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5589     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
5590                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5591 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5592 
5593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5594     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
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 blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
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 resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
5604                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5606     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5607     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
5608                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5609 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5610 
5611     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5612     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
5613                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5614 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5616     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
5617                          Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5618 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5619 
5620     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5621     void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5622 
5623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5624     void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5625 
5626     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5627     void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5628 
5629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5630     void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
5631                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5632 
5633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5634     void setViewportWithCount( uint32_t                               viewportCount,
5635                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
5636                                Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5637 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5639     void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
5640                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5642 
5643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5644     void setScissorWithCount( uint32_t                             scissorCount,
5645                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
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 setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
5650                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5651 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5652 
5653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5654     void bindVertexBuffers2( uint32_t                                 firstBinding,
5655                              uint32_t                                 bindingCount,
5656                              const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5657                              const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5658                              const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5659                              const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
5660                              Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5662     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5663     void bindVertexBuffers2(
5664       uint32_t                                                                                 firstBinding,
5665       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
5666       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
5667       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5668       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5669       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5671 
5672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5673     void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
5674                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5675 
5676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5677     void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
5678                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5679 
5680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5681     void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
5682                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5683 
5684     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5685     void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
5686                                    Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5687 
5688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5689     void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
5690                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5691 
5692     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5693     void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5694                        VULKAN_HPP_NAMESPACE::StencilOp        failOp,
5695                        VULKAN_HPP_NAMESPACE::StencilOp        passOp,
5696                        VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
5697                        VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
5698                        Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5699 
5700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5701     void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
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 setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
5706                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5707 
5708     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5709     void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
5710                                     Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5711 
5712     //=== VK_VERSION_1_4 ===
5713 
5714     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5715     void setLineStipple( uint32_t           lineStippleFactor,
5716                          uint16_t           lineStipplePattern,
5717                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5718 
5719     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5720     void bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5721                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
5722                            VULKAN_HPP_NAMESPACE::DeviceSize size,
5723                            VULKAN_HPP_NAMESPACE::IndexType  indexType,
5724                            Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5725 
5726     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5727     void pushDescriptorSet( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
5728                             VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
5729                             uint32_t                                         set,
5730                             uint32_t                                         descriptorWriteCount,
5731                             const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
5732                             Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5735     void pushDescriptorSet( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                                  pipelineBindPoint,
5736                             VULKAN_HPP_NAMESPACE::PipelineLayout                                                     layout,
5737                             uint32_t                                                                                 set,
5738                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
5739                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5740 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5741 
5742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5743     void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5744                                         VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
5745                                         uint32_t                                       set,
5746                                         const void *                                   pData,
5747                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5749     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5750     void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5751                                         VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
5752                                         uint32_t                                       set,
5753                                         DataType const &                               data,
5754                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5755 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5756 
5757     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5758     void setRenderingAttachmentLocations( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo * pLocationInfo,
5759                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5762     void setRenderingAttachmentLocations( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo,
5763                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5765 
5766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5767     void setRenderingInputAttachmentIndices( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
5768                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5769 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5770     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5771     void setRenderingInputAttachmentIndices( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
5772                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5773 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5774 
5775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5776     void bindDescriptorSets2( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
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 bindDescriptorSets2( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo,
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 pushConstants2( const VULKAN_HPP_NAMESPACE::PushConstantsInfo * pPushConstantsInfo,
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 pushConstants2( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo,
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 pushDescriptorSet2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo * pPushDescriptorSetInfo,
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 pushDescriptorSet2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo,
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 pushDescriptorSetWithTemplate2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
5804                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5805 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5806     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5807     void pushDescriptorSetWithTemplate2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
5808                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5809 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5810 
5811     //=== VK_EXT_debug_marker ===
5812 
5813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5814     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5815                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5816 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5818     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5819                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5821 
5822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5823     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5824 
5825     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5826     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5827                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5830     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5831                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5833 
5834     //=== VK_KHR_video_queue ===
5835 
5836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5837     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
5838                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5839 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5840     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5841     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
5842                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5843 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5844 
5845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5846     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
5847                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5848 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5849     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5850     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
5851                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5853 
5854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5855     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
5856                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5857 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5859     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
5860                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5862 
5863     //=== VK_KHR_video_decode_queue ===
5864 
5865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5866     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,
5867                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5868 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5869     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5870     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,
5871                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5872 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5873 
5874     //=== VK_EXT_transform_feedback ===
5875 
5876     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5877     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
5878                                           uint32_t                                 bindingCount,
5879                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
5880                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5881                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5882                                           Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5885     void bindTransformFeedbackBuffersEXT( uint32_t                                                                         firstBinding,
5886                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
5887                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5888                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
5889                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5890                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5891 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5892 
5893     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5894     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
5895                                     uint32_t                                 counterBufferCount,
5896                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
5897                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5898                                     Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5900     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5901     void beginTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,
5902                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5903                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5904                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5905                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5907 
5908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5909     void endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
5910                                   uint32_t                                 counterBufferCount,
5911                                   const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
5912                                   const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5913                                   Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5916     void endTransformFeedbackEXT( uint32_t                                                                     firstCounterBuffer,
5917                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5918                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5919                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5920                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
5921 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5922 
5923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5924     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
5925                                uint32_t                                query,
5926                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
5927                                uint32_t                                index,
5928                                Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5929 
5930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5931     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5932                              uint32_t                        query,
5933                              uint32_t                        index,
5934                              Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5935 
5936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5937     void drawIndirectByteCountEXT( uint32_t                         instanceCount,
5938                                    uint32_t                         firstInstance,
5939                                    VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
5940                                    VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
5941                                    uint32_t                         counterOffset,
5942                                    uint32_t                         vertexStride,
5943                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5944 
5945     //=== VK_NVX_binary_import ===
5946 
5947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5948     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
5949                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5952     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,
5953                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5954 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5955 
5956     //=== VK_AMD_draw_indirect_count ===
5957 
5958     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5959     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5960                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
5961                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5962                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5963                                uint32_t                         maxDrawCount,
5964                                uint32_t                         stride,
5965                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5966 
5967     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5968     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
5969                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
5970                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
5971                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5972                                       uint32_t                         maxDrawCount,
5973                                       uint32_t                         stride,
5974                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5975 
5976     //=== VK_KHR_dynamic_rendering ===
5977 
5978     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5979     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
5980                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5981 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5983     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
5984                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5985 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5986 
5987     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5988     void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5989 
5990     //=== VK_KHR_device_group ===
5991 
5992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5993     void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5994 
5995     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5996     void dispatchBaseKHR( uint32_t           baseGroupX,
5997                           uint32_t           baseGroupY,
5998                           uint32_t           baseGroupZ,
5999                           uint32_t           groupCountX,
6000                           uint32_t           groupCountY,
6001                           uint32_t           groupCountZ,
6002                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6003 
6004     //=== VK_KHR_push_descriptor ===
6005 
6006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6007     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
6008                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
6009                                uint32_t                                         set,
6010                                uint32_t                                         descriptorWriteCount,
6011                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
6012                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6015     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                                  pipelineBindPoint,
6016                                VULKAN_HPP_NAMESPACE::PipelineLayout                                                     layout,
6017                                uint32_t                                                                                 set,
6018                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
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 pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
6024                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
6025                                            uint32_t                                       set,
6026                                            const void *                                   pData,
6027                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6028 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6029     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6030     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
6031                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
6032                                            uint32_t                                       set,
6033                                            DataType const &                               data,
6034                                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6035 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6036 
6037     //=== VK_EXT_conditional_rendering ===
6038 
6039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6040     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
6041                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6044     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
6045                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6046 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6047 
6048     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6049     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6050 
6051     //=== VK_NV_clip_space_w_scaling ===
6052 
6053     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6054     void setViewportWScalingNV( uint32_t                                         firstViewport,
6055                                 uint32_t                                         viewportCount,
6056                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
6057                                 Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6060     void setViewportWScalingNV( uint32_t                                                                                 firstViewport,
6061                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
6062                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6063 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6064 
6065     //=== VK_EXT_discard_rectangles ===
6066 
6067     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6068     void setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
6069                                  uint32_t                             discardRectangleCount,
6070                                  const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
6071                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6072 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6074     void setDiscardRectangleEXT( uint32_t                                                                     firstDiscardRectangle,
6075                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
6076                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6078 
6079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6080     void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable,
6081                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6082 
6083     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6084     void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode,
6085                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6086 
6087     //=== VK_KHR_create_renderpass2 ===
6088 
6089     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6090     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
6091                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
6092                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6093 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6095     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
6096                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
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 nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
6102                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
6103                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6106     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
6107                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
6108                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6110 
6111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6112     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
6113                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6116     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
6117                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6118 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6119 
6120     //=== VK_EXT_debug_utils ===
6121 
6122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6123     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
6124                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6126     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6127     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
6128                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6129 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6130 
6131     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6132     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6133 
6134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6135     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
6136                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6137 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6139     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
6140                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6141 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6142 
6143 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6144     //=== VK_AMDX_shader_enqueue ===
6145 
6146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6147     void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
6148                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6149 
6150     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6151     void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
6152                             const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
6153                             Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6154 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6156     void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
6157                             const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
6158                             Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6159 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6160 
6161     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6162     void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
6163                                     const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
6164                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6165 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6166     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6167     void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress                      scratch,
6168                                     const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
6169                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6170 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6171 
6172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6173     void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
6174                                          VULKAN_HPP_NAMESPACE::DeviceAddress countInfo,
6175                                          Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6176 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
6177 
6178     //=== VK_EXT_sample_locations ===
6179 
6180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6181     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
6182                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6185     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
6186                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6187 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6188 
6189     //=== VK_KHR_acceleration_structure ===
6190 
6191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6192     void buildAccelerationStructuresKHR( uint32_t                                                                     infoCount,
6193                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
6194                                          const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
6195                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6197     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6198     void buildAccelerationStructuresKHR(
6199       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
6200       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
6201       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6202 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6203 
6204     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6205     void buildAccelerationStructuresIndirectKHR( uint32_t                                                                infoCount,
6206                                                  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
6207                                                  const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
6208                                                  const uint32_t *                                                        pIndirectStrides,
6209                                                  const uint32_t * const *                                                ppMaxPrimitiveCounts,
6210                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6211 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6213     void buildAccelerationStructuresIndirectKHR(
6214       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
6215       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
6216       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                                                        indirectStrides,
6217       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
6218       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6219 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6220 
6221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6222     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
6223                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6225     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6226     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
6227                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6229 
6230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6231     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
6232                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6233 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6235     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
6236                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6238 
6239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6240     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
6241                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6242 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6243     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6244     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
6245                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6247 
6248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6249     void writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,
6250                                                    const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
6251                                                    VULKAN_HPP_NAMESPACE::QueryType                        queryType,
6252                                                    VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
6253                                                    uint32_t                                               firstQuery,
6254                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6257     void writeAccelerationStructuresPropertiesKHR(
6258       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
6259       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
6260       VULKAN_HPP_NAMESPACE::QueryPool                                                                queryPool,
6261       uint32_t                                                                                       firstQuery,
6262       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6264 
6265     //=== VK_KHR_ray_tracing_pipeline ===
6266 
6267     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6268     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
6269                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
6270                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
6271                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
6272                        uint32_t                                                    width,
6273                        uint32_t                                                    height,
6274                        uint32_t                                                    depth,
6275                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6278     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
6279                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
6280                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
6281                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
6282                        uint32_t                                                    width,
6283                        uint32_t                                                    height,
6284                        uint32_t                                                    depth,
6285                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6286 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6287 
6288     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6289     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
6290                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
6291                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
6292                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
6293                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
6294                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6297     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
6298                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
6299                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
6300                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
6301                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
6302                                Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6304 
6305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6306     void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6307 
6308     //=== VK_NV_shading_rate_image ===
6309 
6310     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6311     void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
6312                                  VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
6313                                  Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6314 
6315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6316     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
6317                                           uint32_t                                           viewportCount,
6318                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
6319                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6322     void setViewportShadingRatePaletteNV( uint32_t                                                                                   firstViewport,
6323                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
6324                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6326 
6327     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6328     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
6329                                  uint32_t                                                customSampleOrderCount,
6330                                  const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
6331                                  Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6334     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                                                   sampleOrderType,
6335                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
6336                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6338 
6339     //=== VK_NV_ray_tracing ===
6340 
6341     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6342     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
6343                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
6344                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
6345                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
6346                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
6347                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
6348                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
6349                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
6350                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6353     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
6354                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
6355                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
6356                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
6357                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
6358                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
6359                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
6360                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
6361                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6363 
6364     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6365     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
6366                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
6367                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
6368                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6369 
6370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6371     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
6372                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
6373                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
6374                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
6375                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
6376                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
6377                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
6378                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
6379                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
6380                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
6381                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
6382                       uint32_t                         width,
6383                       uint32_t                         height,
6384                       uint32_t                         depth,
6385                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6386 
6387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6388     void writeAccelerationStructuresPropertiesNV( uint32_t                                              accelerationStructureCount,
6389                                                   const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
6390                                                   VULKAN_HPP_NAMESPACE::QueryType                       queryType,
6391                                                   VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
6392                                                   uint32_t                                              firstQuery,
6393                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6396     void writeAccelerationStructuresPropertiesNV(
6397       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
6398       VULKAN_HPP_NAMESPACE::QueryType                                                               queryType,
6399       VULKAN_HPP_NAMESPACE::QueryPool                                                               queryPool,
6400       uint32_t                                                                                      firstQuery,
6401       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6403 
6404     //=== VK_KHR_draw_indirect_count ===
6405 
6406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6407     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6408                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
6409                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6410                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6411                                uint32_t                         maxDrawCount,
6412                                uint32_t                         stride,
6413                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6414 
6415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6416     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6417                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
6418                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6419                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6420                                       uint32_t                         maxDrawCount,
6421                                       uint32_t                         stride,
6422                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6423 
6424     //=== VK_AMD_buffer_marker ===
6425 
6426     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6427     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
6428                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
6429                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
6430                                uint32_t                                    marker,
6431                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6432 
6433     //=== VK_NV_mesh_shader ===
6434 
6435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6436     void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6437 
6438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6439     void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6440                                   VULKAN_HPP_NAMESPACE::DeviceSize offset,
6441                                   uint32_t                         drawCount,
6442                                   uint32_t                         stride,
6443                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6444 
6445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6446     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6447                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
6448                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6449                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6450                                        uint32_t                         maxDrawCount,
6451                                        uint32_t                         stride,
6452                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6453 
6454     //=== VK_NV_scissor_exclusive ===
6455 
6456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6457     void setExclusiveScissorEnableNV( uint32_t                             firstExclusiveScissor,
6458                                       uint32_t                             exclusiveScissorCount,
6459                                       const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,
6460                                       Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6461 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6462     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6463     void setExclusiveScissorEnableNV( uint32_t                                                                     firstExclusiveScissor,
6464                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,
6465                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6466 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6467 
6468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6469     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
6470                                 uint32_t                             exclusiveScissorCount,
6471                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
6472                                 Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6473 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6475     void setExclusiveScissorNV( uint32_t                                                                     firstExclusiveScissor,
6476                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
6477                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6478 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6479 
6480     //=== VK_NV_device_diagnostic_checkpoints ===
6481 
6482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6483     void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6484 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6485     template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6486     void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
6487                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6489 
6490     //=== VK_INTEL_performance_query ===
6491 
6492     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6493     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
6494                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6495 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6497     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6498       setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,
6499                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6500 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6501 
6502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6503     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
6504                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6507     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6508       setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,
6509                                        Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6511 
6512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6513     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
6514                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6515 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6517     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6518       setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,
6519                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6520 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6521 
6522     //=== VK_KHR_fragment_shading_rate ===
6523 
6524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6525     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
6526                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6527                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6528 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6530     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,
6531                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6532                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6533 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6534 
6535     //=== VK_KHR_dynamic_rendering_local_read ===
6536 
6537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6538     void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo * pLocationInfo,
6539                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6542     void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo,
6543                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6545 
6546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6547     void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo,
6548                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6551     void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo,
6552                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6553 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6554 
6555     //=== VK_EXT_line_rasterization ===
6556 
6557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6558     void setLineStippleEXT( uint32_t           lineStippleFactor,
6559                             uint16_t           lineStipplePattern,
6560                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6561 
6562     //=== VK_EXT_extended_dynamic_state ===
6563 
6564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6565     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6566 
6567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6568     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6569 
6570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6571     void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
6572                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6573 
6574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6575     void setViewportWithCountEXT( uint32_t                               viewportCount,
6576                                   const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
6577                                   Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6578 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6580     void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
6581                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6582 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6583 
6584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6585     void setScissorWithCountEXT( uint32_t                             scissorCount,
6586                                  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
6587                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6590     void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
6591                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6592 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6593 
6594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6595     void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
6596                                 uint32_t                                 bindingCount,
6597                                 const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
6598                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
6599                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
6600                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
6601                                 Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6604     void bindVertexBuffers2EXT(
6605       uint32_t                                                                                 firstBinding,
6606       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
6607       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
6608       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6609       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6610       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6612 
6613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6614     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
6615                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6616 
6617     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6618     void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
6619                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6620 
6621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6622     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
6623                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6624 
6625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6626     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
6627                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6628 
6629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6630     void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
6631                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6632 
6633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6634     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
6635                           VULKAN_HPP_NAMESPACE::StencilOp        failOp,
6636                           VULKAN_HPP_NAMESPACE::StencilOp        passOp,
6637                           VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
6638                           VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
6639                           Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6640 
6641     //=== VK_NV_device_generated_commands ===
6642 
6643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6644     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
6645                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6647     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6648     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
6649                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6650 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6651 
6652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6653     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
6654                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
6655                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6658     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
6659                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
6660                                      Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6661 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6662 
6663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6664     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6665                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
6666                                     uint32_t                                groupIndex,
6667                                     Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6668 
6669     //=== VK_EXT_depth_bias_control ===
6670 
6671     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6672     void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo,
6673                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6674 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6676     void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo,
6677                            Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6678 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6679 
6680     //=== VK_KHR_video_encode_queue ===
6681 
6682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6683     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
6684                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6685 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6687     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
6688                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6689 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6690 
6691 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6692     //=== VK_NV_cuda_kernel_launch ===
6693 
6694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6695     void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo,
6696                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6697 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6698     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6699     void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo,
6700                              Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6701 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6702 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
6703 
6704     //=== VK_KHR_synchronization2 ===
6705 
6706     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6707     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
6708                        const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
6709                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6712     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
6713                        const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
6714                        Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6715 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6716 
6717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6718     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event               event,
6719                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask,
6720                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6721 
6722     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6723     void waitEvents2KHR( uint32_t                                     eventCount,
6724                          const VULKAN_HPP_NAMESPACE::Event *          pEvents,
6725                          const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
6726                          Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6728     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6729     void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &          events,
6730                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
6731                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6732 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6733 
6734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6735     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
6736                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6737 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6739     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
6740                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6741 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6742 
6743     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6744     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
6745                              VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
6746                              uint32_t                                  query,
6747                              Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6748 
6749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6750     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
6751                                 VULKAN_HPP_NAMESPACE::Buffer              dstBuffer,
6752                                 VULKAN_HPP_NAMESPACE::DeviceSize          dstOffset,
6753                                 uint32_t                                  marker,
6754                                 Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6755 
6756     //=== VK_EXT_descriptor_buffer ===
6757 
6758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6759     void bindDescriptorBuffersEXT( uint32_t                                                     bufferCount,
6760                                    const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos,
6761                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6764     void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos,
6765                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6766 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6767 
6768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6769     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint  pipelineBindPoint,
6770                                         VULKAN_HPP_NAMESPACE::PipelineLayout     layout,
6771                                         uint32_t                                 firstSet,
6772                                         uint32_t                                 setCount,
6773                                         const uint32_t *                         pBufferIndices,
6774                                         const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
6775                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6776 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6778     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint                                          pipelineBindPoint,
6779                                         VULKAN_HPP_NAMESPACE::PipelineLayout                                             layout,
6780                                         uint32_t                                                                         firstSet,
6781                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const &                         bufferIndices,
6782                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
6783                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
6784 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6785 
6786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6787     void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6788                                                   VULKAN_HPP_NAMESPACE::PipelineLayout    layout,
6789                                                   uint32_t                                set,
6790                                                   Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6791 
6792     //=== VK_NV_fragment_shading_rate_enums ===
6793 
6794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6795     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
6796                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
6797                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6798 
6799     //=== VK_EXT_mesh_shader ===
6800 
6801     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6802     void drawMeshTasksEXT( uint32_t           groupCountX,
6803                            uint32_t           groupCountY,
6804                            uint32_t           groupCountZ,
6805                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6806 
6807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6808     void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6809                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
6810                                    uint32_t                         drawCount,
6811                                    uint32_t                         stride,
6812                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6813 
6814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6815     void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer     buffer,
6816                                         VULKAN_HPP_NAMESPACE::DeviceSize offset,
6817                                         VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
6818                                         VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6819                                         uint32_t                         maxDrawCount,
6820                                         uint32_t                         stride,
6821                                         Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6822 
6823     //=== VK_KHR_copy_commands2 ===
6824 
6825     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6826     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
6827                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6830     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
6831                          Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6833 
6834     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6835     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
6836                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6838     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6839     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
6840                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6842 
6843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6844     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
6845                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6846 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6848     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
6849                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6850 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6851 
6852     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6853     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
6854                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6856     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6857     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
6858                                 Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6859 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6860 
6861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6862     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
6863                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6864 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6866     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
6867                         Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6869 
6870     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6871     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
6872                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6875     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
6876                            Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6877 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6878 
6879     //=== VK_EXT_vertex_input_dynamic_state ===
6880 
6881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6882     void setVertexInputEXT( uint32_t                                                          vertexBindingDescriptionCount,
6883                             const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT *   pVertexBindingDescriptions,
6884                             uint32_t                                                          vertexAttributeDescriptionCount,
6885                             const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
6886                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6889     void
6890       setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
6891                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
6892                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6894 
6895     //=== VK_HUAWEI_subpass_shading ===
6896 
6897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6898     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6899 
6900     //=== VK_HUAWEI_invocation_mask ===
6901 
6902     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6903     void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,
6904                                    VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
6905                                    Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6906 
6907     //=== VK_EXT_extended_dynamic_state2 ===
6908 
6909     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6910     void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6911 
6912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6913     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
6914                                         Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6915 
6916     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6917     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
6918                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6919 
6920     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6921     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6922 
6923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6924     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
6925                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6926 
6927     //=== VK_EXT_color_write_enable ===
6928 
6929     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6930     void setColorWriteEnableEXT( uint32_t                             attachmentCount,
6931                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
6932                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6933 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6935     void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
6936                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6938 
6939     //=== VK_KHR_ray_tracing_maintenance1 ===
6940 
6941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6942     void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
6943                                 Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6944 
6945     //=== VK_EXT_multi_draw ===
6946 
6947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6948     void drawMultiEXT( uint32_t                                       drawCount,
6949                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
6950                        uint32_t                                       instanceCount,
6951                        uint32_t                                       firstInstance,
6952                        uint32_t                                       stride,
6953                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6956     void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
6957                        uint32_t                                                                                      instanceCount,
6958                        uint32_t                                                                                      firstInstance,
6959                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6960 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6961 
6962     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6963     void drawMultiIndexedEXT( uint32_t                                              drawCount,
6964                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
6965                               uint32_t                                              instanceCount,
6966                               uint32_t                                              firstInstance,
6967                               uint32_t                                              stride,
6968                               const int32_t *                                       pVertexOffset,
6969                               Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6970 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6972     void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
6973                               uint32_t                                                                                             instanceCount,
6974                               uint32_t                                                                                             firstInstance,
6975                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6976                               Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6977 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6978 
6979     //=== VK_EXT_opacity_micromap ===
6980 
6981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6982     void buildMicromapsEXT( uint32_t                                           infoCount,
6983                             const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
6984                             Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6986     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6987     void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
6988                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6989 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6990 
6991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6992     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
6993                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6994 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6995     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6996     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
6997                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6998 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6999 
7000     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7001     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
7002                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7003 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7005     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
7006                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7007 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7008 
7009     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7010     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
7011                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7012 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7013     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7014     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
7015                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7016 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7017 
7018     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7019     void writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,
7020                                       const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
7021                                       VULKAN_HPP_NAMESPACE::QueryType           queryType,
7022                                       VULKAN_HPP_NAMESPACE::QueryPool           queryPool,
7023                                       uint32_t                                  firstQuery,
7024                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7027     void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
7028                                       VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
7029                                       VULKAN_HPP_NAMESPACE::QueryPool                                                   queryPool,
7030                                       uint32_t                                                                          firstQuery,
7031                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7032 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7033 
7034     //=== VK_HUAWEI_cluster_culling_shader ===
7035 
7036     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7037     void drawClusterHUAWEI( uint32_t           groupCountX,
7038                             uint32_t           groupCountY,
7039                             uint32_t           groupCountZ,
7040                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7041 
7042     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7043     void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer     buffer,
7044                                     VULKAN_HPP_NAMESPACE::DeviceSize offset,
7045                                     Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7046 
7047     //=== VK_NV_copy_memory_indirect ===
7048 
7049     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7050     void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
7051                                uint32_t                            copyCount,
7052                                uint32_t                            stride,
7053                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7054 
7055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7056     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                  copyBufferAddress,
7057                                       uint32_t                                             copyCount,
7058                                       uint32_t                                             stride,
7059                                       VULKAN_HPP_NAMESPACE::Image                          dstImage,
7060                                       VULKAN_HPP_NAMESPACE::ImageLayout                    dstImageLayout,
7061                                       const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,
7062                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7065     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress                                                          copyBufferAddress,
7066                                       uint32_t                                                                                     stride,
7067                                       VULKAN_HPP_NAMESPACE::Image                                                                  dstImage,
7068                                       VULKAN_HPP_NAMESPACE::ImageLayout                                                            dstImageLayout,
7069                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources,
7070                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7072 
7073     //=== VK_NV_memory_decompression ===
7074 
7075     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7076     void decompressMemoryNV( uint32_t                                               decompressRegionCount,
7077                              const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,
7078                              Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7079 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7080     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7081     void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions,
7082                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7083 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7084 
7085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7086     void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
7087                                           VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
7088                                           uint32_t                            stride,
7089                                           Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7090 
7091     //=== VK_NV_device_generated_commands_compute ===
7092 
7093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7094     void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
7095                                          VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
7096                                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7097 
7098     //=== VK_EXT_extended_dynamic_state3 ===
7099 
7100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7101     void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable,
7102                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7103 
7104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7105     void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode,
7106                             Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7107 
7108     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7109     void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples,
7110                                      Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7111 
7112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7113     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
7114                            const VULKAN_HPP_NAMESPACE::SampleMask *  pSampleMask,
7115                            Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7116 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7117     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7118     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits                                        samples,
7119                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask,
7120                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7121 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7122 
7123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7124     void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable,
7125                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7126 
7127     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7128     void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable,
7129                                  Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7130 
7131     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7132     void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable,
7133                               Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7134 
7135     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7136     void setColorBlendEnableEXT( uint32_t                             firstAttachment,
7137                                  uint32_t                             attachmentCount,
7138                                  const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,
7139                                  Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7141     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7142     void setColorBlendEnableEXT( uint32_t                                                                     firstAttachment,
7143                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables,
7144                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7145 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7146 
7147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7148     void setColorBlendEquationEXT( uint32_t                                            firstAttachment,
7149                                    uint32_t                                            attachmentCount,
7150                                    const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,
7151                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7152 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7153     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7154     void setColorBlendEquationEXT( uint32_t                                                                                    firstAttachment,
7155                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations,
7156                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7157 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7158 
7159     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7160     void setColorWriteMaskEXT( uint32_t                                          firstAttachment,
7161                                uint32_t                                          attachmentCount,
7162                                const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,
7163                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7166     void setColorWriteMaskEXT( uint32_t                                                                                  firstAttachment,
7167                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks,
7168                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7170 
7171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7172     void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin,
7173                                          Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7174 
7175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7176     void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7177 
7178     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7179     void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode,
7180                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7181 
7182     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7183     void setExtraPrimitiveOverestimationSizeEXT( float              extraPrimitiveOverestimationSize,
7184                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7185 
7186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7187     void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable,
7188                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7189 
7190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7191     void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable,
7192                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7193 
7194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7195     void setColorBlendAdvancedEXT( uint32_t                                            firstAttachment,
7196                                    uint32_t                                            attachmentCount,
7197                                    const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,
7198                                    Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7201     void setColorBlendAdvancedEXT( uint32_t                                                                                    firstAttachment,
7202                                    VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced,
7203                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7204 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7205 
7206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7207     void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode,
7208                                     Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7209 
7210     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7211     void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode,
7212                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7213 
7214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7215     void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable,
7216                                   Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7217 
7218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7219     void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne,
7220                                           Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7221 
7222     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7223     void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable,
7224                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7225 
7226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7227     void setViewportSwizzleNV( uint32_t                                        firstViewport,
7228                                uint32_t                                        viewportCount,
7229                                const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,
7230                                Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7233     void setViewportSwizzleNV( uint32_t                                                                                firstViewport,
7234                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles,
7235                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7237 
7238     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7239     void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable,
7240                                      Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7241 
7242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7243     void setCoverageToColorLocationNV( uint32_t           coverageToColorLocation,
7244                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7245 
7246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7247     void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode,
7248                                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7249 
7250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7251     void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable,
7252                                              Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7253 
7254     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7255     void setCoverageModulationTableNV( uint32_t           coverageModulationTableCount,
7256                                        const float *      pCoverageModulationTable,
7257                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7258 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7259     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7260     void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable,
7261                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7262 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7263 
7264     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7265     void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable,
7266                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7267 
7268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7269     void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable,
7270                                                 Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7271 
7272     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7273     void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode,
7274                                      Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7275 
7276     //=== VK_NV_optical_flow ===
7277 
7278     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7279     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
7280                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo,
7281                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7282 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7284     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
7285                                const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo,
7286                                Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7288 
7289     //=== VK_KHR_maintenance5 ===
7290 
7291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7292     void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
7293                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
7294                               VULKAN_HPP_NAMESPACE::DeviceSize size,
7295                               VULKAN_HPP_NAMESPACE::IndexType  indexType,
7296                               Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7297 
7298     //=== VK_EXT_shader_object ===
7299 
7300     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7301     void bindShadersEXT( uint32_t                                          stageCount,
7302                          const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages,
7303                          const VULKAN_HPP_NAMESPACE::ShaderEXT *           pShaders,
7304                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7307     void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,
7308                          VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const &           shaders,
7309                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
7310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7311 
7312     //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
7313 
7314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7315     void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask,
7316                                              Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7317 
7318     //=== VK_KHR_line_rasterization ===
7319 
7320     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7321     void setLineStippleKHR( uint32_t           lineStippleFactor,
7322                             uint16_t           lineStipplePattern,
7323                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7324 
7325     //=== VK_KHR_maintenance6 ===
7326 
7327     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7328     void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo * pBindDescriptorSetsInfo,
7329                                  Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7332     void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo,
7333                                  Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7334 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7335 
7336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7337     void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfo * pPushConstantsInfo,
7338                             Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7339 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7341     void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo,
7342                             Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7344 
7345     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7346     void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo * pPushDescriptorSetInfo,
7347                                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7348 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7350     void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo,
7351                                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7352 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7353 
7354     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7355     void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo,
7356                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7358     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7359     void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo,
7360                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7362 
7363     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7364     void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
7365                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7368     void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
7369                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7371 
7372     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7373     void bindDescriptorBufferEmbeddedSamplers2EXT(
7374       const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
7375       Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7377     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7378     void bindDescriptorBufferEmbeddedSamplers2EXT(
7379       const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
7380       Dispatch const & d                                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7381 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7382 
operator VkCommandBuffer() const7383     operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
7384     {
7385       return m_commandBuffer;
7386     }
7387 
operator bool() const7388     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7389     {
7390       return m_commandBuffer != VK_NULL_HANDLE;
7391     }
7392 
operator !() const7393     bool operator!() const VULKAN_HPP_NOEXCEPT
7394     {
7395       return m_commandBuffer == VK_NULL_HANDLE;
7396     }
7397 
7398   private:
7399     VkCommandBuffer m_commandBuffer = {};
7400   };
7401 
7402   template <>
7403   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
7404   {
7405     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
7406   };
7407 
7408   template <>
7409   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
7410   {
7411     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
7412   };
7413 
7414 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7415   template <>
7416   struct CppType<VkCommandBuffer, VK_NULL_HANDLE>
7417   {
7418     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
7419   };
7420 #endif
7421 
7422   template <>
7423   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
7424   {
7425     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7426   };
7427 
7428   class DeviceMemory
7429   {
7430   public:
7431     using CType      = VkDeviceMemory;
7432     using NativeType = VkDeviceMemory;
7433 
7434     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
7435     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7436       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
7437 
7438   public:
DeviceMemory()7439     DeviceMemory() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
7440     DeviceMemory( DeviceMemory const & rhs )             = default;
7441     DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
7442 
7443 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
7444     DeviceMemory( DeviceMemory && rhs )             = default;
7445     DeviceMemory & operator=( DeviceMemory && rhs ) = default;
7446 #else
DeviceMemory(DeviceMemory && rhs)7447     DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) ) {}
7448 
operator =(DeviceMemory && rhs)7449     DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
7450     {
7451       m_deviceMemory = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} );
7452       return *this;
7453     }
7454 #endif
7455 
DeviceMemory(std::nullptr_t)7456     VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7457 
DeviceMemory(VkDeviceMemory deviceMemory)7458     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
7459 
7460 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDeviceMemory deviceMemory)7461     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
7462     {
7463       m_deviceMemory = deviceMemory;
7464       return *this;
7465     }
7466 #endif
7467 
operator =(std::nullptr_t)7468     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7469     {
7470       m_deviceMemory = {};
7471       return *this;
7472     }
7473 
7474 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7475     auto operator<=>( DeviceMemory const & ) const = default;
7476 #else
operator ==(DeviceMemory const & rhs) const7477     bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
7478     {
7479       return m_deviceMemory == rhs.m_deviceMemory;
7480     }
7481 
operator !=(DeviceMemory const & rhs) const7482     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
7483     {
7484       return m_deviceMemory != rhs.m_deviceMemory;
7485     }
7486 
operator <(DeviceMemory const & rhs) const7487     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
7488     {
7489       return m_deviceMemory < rhs.m_deviceMemory;
7490     }
7491 #endif
7492 
operator VkDeviceMemory() const7493     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
7494     {
7495       return m_deviceMemory;
7496     }
7497 
operator bool() const7498     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7499     {
7500       return m_deviceMemory != VK_NULL_HANDLE;
7501     }
7502 
operator !() const7503     bool operator!() const VULKAN_HPP_NOEXCEPT
7504     {
7505       return m_deviceMemory == VK_NULL_HANDLE;
7506     }
7507 
7508   private:
7509     VkDeviceMemory m_deviceMemory = {};
7510   };
7511 
7512   template <>
7513   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
7514   {
7515     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
7516   };
7517 
7518   template <>
7519   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
7520   {
7521     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
7522   };
7523 
7524 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7525   template <>
7526   struct CppType<VkDeviceMemory, VK_NULL_HANDLE>
7527   {
7528     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
7529   };
7530 #endif
7531 
7532   template <>
7533   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
7534   {
7535     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7536   };
7537 
7538   class VideoSessionKHR
7539   {
7540   public:
7541     using CType      = VkVideoSessionKHR;
7542     using NativeType = VkVideoSessionKHR;
7543 
7544     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
7545     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7546       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7547 
7548   public:
VideoSessionKHR()7549     VideoSessionKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
7550     VideoSessionKHR( VideoSessionKHR const & rhs )             = default;
7551     VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default;
7552 
7553 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
7554     VideoSessionKHR( VideoSessionKHR && rhs )             = default;
7555     VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default;
7556 #else
VideoSessionKHR(VideoSessionKHR && rhs)7557     VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ) ) {}
7558 
operator =(VideoSessionKHR && rhs)7559     VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
7560     {
7561       m_videoSessionKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} );
7562       return *this;
7563     }
7564 #endif
7565 
VideoSessionKHR(std::nullptr_t)7566     VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7567 
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)7568     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
7569 
7570 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkVideoSessionKHR videoSessionKHR)7571     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
7572     {
7573       m_videoSessionKHR = videoSessionKHR;
7574       return *this;
7575     }
7576 #endif
7577 
operator =(std::nullptr_t)7578     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7579     {
7580       m_videoSessionKHR = {};
7581       return *this;
7582     }
7583 
7584 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7585     auto operator<=>( VideoSessionKHR const & ) const = default;
7586 #else
operator ==(VideoSessionKHR const & rhs) const7587     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7588     {
7589       return m_videoSessionKHR == rhs.m_videoSessionKHR;
7590     }
7591 
operator !=(VideoSessionKHR const & rhs) const7592     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7593     {
7594       return m_videoSessionKHR != rhs.m_videoSessionKHR;
7595     }
7596 
operator <(VideoSessionKHR const & rhs) const7597     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7598     {
7599       return m_videoSessionKHR < rhs.m_videoSessionKHR;
7600     }
7601 #endif
7602 
operator VkVideoSessionKHR() const7603     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
7604     {
7605       return m_videoSessionKHR;
7606     }
7607 
operator bool() const7608     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7609     {
7610       return m_videoSessionKHR != VK_NULL_HANDLE;
7611     }
7612 
operator !() const7613     bool operator!() const VULKAN_HPP_NOEXCEPT
7614     {
7615       return m_videoSessionKHR == VK_NULL_HANDLE;
7616     }
7617 
7618   private:
7619     VkVideoSessionKHR m_videoSessionKHR = {};
7620   };
7621 
7622   template <>
7623   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
7624   {
7625     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
7626   };
7627 
7628 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7629   template <>
7630   struct CppType<VkVideoSessionKHR, VK_NULL_HANDLE>
7631   {
7632     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
7633   };
7634 #endif
7635 
7636   template <>
7637   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
7638   {
7639     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7640   };
7641 
7642   class DeferredOperationKHR
7643   {
7644   public:
7645     using CType      = VkDeferredOperationKHR;
7646     using NativeType = VkDeferredOperationKHR;
7647 
7648     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
7649     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7650       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7651 
7652   public:
DeferredOperationKHR()7653     DeferredOperationKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
7654     DeferredOperationKHR( DeferredOperationKHR const & rhs )             = default;
7655     DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default;
7656 
7657 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
7658     DeferredOperationKHR( DeferredOperationKHR && rhs )             = default;
7659     DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default;
7660 #else
DeferredOperationKHR(DeferredOperationKHR && rhs)7661     DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
7662       : m_deferredOperationKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} ) )
7663     {
7664     }
7665 
operator =(DeferredOperationKHR && rhs)7666     DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
7667     {
7668       m_deferredOperationKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} );
7669       return *this;
7670     }
7671 #endif
7672 
DeferredOperationKHR(std::nullptr_t)7673     VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7674 
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)7675     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
7676       : m_deferredOperationKHR( deferredOperationKHR )
7677     {
7678     }
7679 
7680 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDeferredOperationKHR deferredOperationKHR)7681     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
7682     {
7683       m_deferredOperationKHR = deferredOperationKHR;
7684       return *this;
7685     }
7686 #endif
7687 
operator =(std::nullptr_t)7688     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7689     {
7690       m_deferredOperationKHR = {};
7691       return *this;
7692     }
7693 
7694 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7695     auto operator<=>( DeferredOperationKHR const & ) const = default;
7696 #else
operator ==(DeferredOperationKHR const & rhs) const7697     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7698     {
7699       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
7700     }
7701 
operator !=(DeferredOperationKHR const & rhs) const7702     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7703     {
7704       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
7705     }
7706 
operator <(DeferredOperationKHR const & rhs) const7707     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
7708     {
7709       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
7710     }
7711 #endif
7712 
operator VkDeferredOperationKHR() const7713     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
7714     {
7715       return m_deferredOperationKHR;
7716     }
7717 
operator bool() const7718     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7719     {
7720       return m_deferredOperationKHR != VK_NULL_HANDLE;
7721     }
7722 
operator !() const7723     bool operator!() const VULKAN_HPP_NOEXCEPT
7724     {
7725       return m_deferredOperationKHR == VK_NULL_HANDLE;
7726     }
7727 
7728   private:
7729     VkDeferredOperationKHR m_deferredOperationKHR = {};
7730   };
7731 
7732   template <>
7733   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
7734   {
7735     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
7736   };
7737 
7738 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7739   template <>
7740   struct CppType<VkDeferredOperationKHR, VK_NULL_HANDLE>
7741   {
7742     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
7743   };
7744 #endif
7745 
7746   template <>
7747   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
7748   {
7749     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7750   };
7751 
7752 #if defined( VK_USE_PLATFORM_FUCHSIA )
7753   class BufferCollectionFUCHSIA
7754   {
7755   public:
7756     using CType      = VkBufferCollectionFUCHSIA;
7757     using NativeType = VkBufferCollectionFUCHSIA;
7758 
7759     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
7760     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7761       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
7762 
7763   public:
BufferCollectionFUCHSIA()7764     BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
7765     BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs )             = default;
7766     BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default;
7767 
7768 #  if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
7769     BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs )             = default;
7770     BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default;
7771 #  else
BufferCollectionFUCHSIA(BufferCollectionFUCHSIA && rhs)7772     BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
7773       : m_bufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ) )
7774     {
7775     }
7776 
operator =(BufferCollectionFUCHSIA && rhs)7777     BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
7778     {
7779       m_bufferCollectionFUCHSIA = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} );
7780       return *this;
7781     }
7782 #  endif
7783 
BufferCollectionFUCHSIA(std::nullptr_t)7784     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7785 
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)7786     VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
7787       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
7788     {
7789     }
7790 
7791 #  if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)7792     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
7793     {
7794       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
7795       return *this;
7796     }
7797 #  endif
7798 
operator =(std::nullptr_t)7799     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7800     {
7801       m_bufferCollectionFUCHSIA = {};
7802       return *this;
7803     }
7804 
7805 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7806     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
7807 #  else
operator ==(BufferCollectionFUCHSIA const & rhs) const7808     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
7809     {
7810       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
7811     }
7812 
operator !=(BufferCollectionFUCHSIA const & rhs) const7813     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
7814     {
7815       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
7816     }
7817 
operator <(BufferCollectionFUCHSIA const & rhs) const7818     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
7819     {
7820       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
7821     }
7822 #  endif
7823 
operator VkBufferCollectionFUCHSIA() const7824     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
7825     {
7826       return m_bufferCollectionFUCHSIA;
7827     }
7828 
operator bool() const7829     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7830     {
7831       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
7832     }
7833 
operator !() const7834     bool operator!() const VULKAN_HPP_NOEXCEPT
7835     {
7836       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
7837     }
7838 
7839   private:
7840     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
7841   };
7842 
7843   template <>
7844   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
7845   {
7846     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
7847   };
7848 
7849   template <>
7850   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
7851   {
7852     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
7853   };
7854 
7855 #  if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7856   template <>
7857   struct CppType<VkBufferCollectionFUCHSIA, VK_NULL_HANDLE>
7858   {
7859     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
7860   };
7861 #  endif
7862 
7863   template <>
7864   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
7865   {
7866     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7867   };
7868 #endif /*VK_USE_PLATFORM_FUCHSIA*/
7869 
7870   class BufferView
7871   {
7872   public:
7873     using CType      = VkBufferView;
7874     using NativeType = VkBufferView;
7875 
7876     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
7877     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7878       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
7879 
7880   public:
BufferView()7881     BufferView() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
7882     BufferView( BufferView const & rhs )             = default;
7883     BufferView & operator=( BufferView const & rhs ) = default;
7884 
7885 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
7886     BufferView( BufferView && rhs )             = default;
7887     BufferView & operator=( BufferView && rhs ) = default;
7888 #else
BufferView(BufferView && rhs)7889     BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) {}
7890 
operator =(BufferView && rhs)7891     BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
7892     {
7893       m_bufferView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} );
7894       return *this;
7895     }
7896 #endif
7897 
BufferView(std::nullptr_t)7898     VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
7899 
BufferView(VkBufferView bufferView)7900     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
7901 
7902 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkBufferView bufferView)7903     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
7904     {
7905       m_bufferView = bufferView;
7906       return *this;
7907     }
7908 #endif
7909 
operator =(std::nullptr_t)7910     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7911     {
7912       m_bufferView = {};
7913       return *this;
7914     }
7915 
7916 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7917     auto operator<=>( BufferView const & ) const = default;
7918 #else
operator ==(BufferView const & rhs) const7919     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7920     {
7921       return m_bufferView == rhs.m_bufferView;
7922     }
7923 
operator !=(BufferView const & rhs) const7924     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7925     {
7926       return m_bufferView != rhs.m_bufferView;
7927     }
7928 
operator <(BufferView const & rhs) const7929     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7930     {
7931       return m_bufferView < rhs.m_bufferView;
7932     }
7933 #endif
7934 
operator VkBufferView() const7935     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
7936     {
7937       return m_bufferView;
7938     }
7939 
operator bool() const7940     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7941     {
7942       return m_bufferView != VK_NULL_HANDLE;
7943     }
7944 
operator !() const7945     bool operator!() const VULKAN_HPP_NOEXCEPT
7946     {
7947       return m_bufferView == VK_NULL_HANDLE;
7948     }
7949 
7950   private:
7951     VkBufferView m_bufferView = {};
7952   };
7953 
7954   template <>
7955   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
7956   {
7957     using Type = VULKAN_HPP_NAMESPACE::BufferView;
7958   };
7959 
7960   template <>
7961   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
7962   {
7963     using Type = VULKAN_HPP_NAMESPACE::BufferView;
7964   };
7965 
7966 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
7967   template <>
7968   struct CppType<VkBufferView, VK_NULL_HANDLE>
7969   {
7970     using Type = VULKAN_HPP_NAMESPACE::BufferView;
7971   };
7972 #endif
7973 
7974   template <>
7975   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
7976   {
7977     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7978   };
7979 
7980   class CommandPool
7981   {
7982   public:
7983     using CType      = VkCommandPool;
7984     using NativeType = VkCommandPool;
7985 
7986     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
7987     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7988       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
7989 
7990   public:
CommandPool()7991     CommandPool() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
7992     CommandPool( CommandPool const & rhs )             = default;
7993     CommandPool & operator=( CommandPool const & rhs ) = default;
7994 
7995 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
7996     CommandPool( CommandPool && rhs )             = default;
7997     CommandPool & operator=( CommandPool && rhs ) = default;
7998 #else
CommandPool(CommandPool && rhs)7999     CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) {}
8000 
operator =(CommandPool && rhs)8001     CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
8002     {
8003       m_commandPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} );
8004       return *this;
8005     }
8006 #endif
8007 
CommandPool(std::nullptr_t)8008     VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8009 
CommandPool(VkCommandPool commandPool)8010     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
8011 
8012 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCommandPool commandPool)8013     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
8014     {
8015       m_commandPool = commandPool;
8016       return *this;
8017     }
8018 #endif
8019 
operator =(std::nullptr_t)8020     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8021     {
8022       m_commandPool = {};
8023       return *this;
8024     }
8025 
8026 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8027     auto operator<=>( CommandPool const & ) const = default;
8028 #else
operator ==(CommandPool const & rhs) const8029     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8030     {
8031       return m_commandPool == rhs.m_commandPool;
8032     }
8033 
operator !=(CommandPool const & rhs) const8034     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8035     {
8036       return m_commandPool != rhs.m_commandPool;
8037     }
8038 
operator <(CommandPool const & rhs) const8039     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8040     {
8041       return m_commandPool < rhs.m_commandPool;
8042     }
8043 #endif
8044 
operator VkCommandPool() const8045     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
8046     {
8047       return m_commandPool;
8048     }
8049 
operator bool() const8050     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8051     {
8052       return m_commandPool != VK_NULL_HANDLE;
8053     }
8054 
operator !() const8055     bool operator!() const VULKAN_HPP_NOEXCEPT
8056     {
8057       return m_commandPool == VK_NULL_HANDLE;
8058     }
8059 
8060   private:
8061     VkCommandPool m_commandPool = {};
8062   };
8063 
8064   template <>
8065   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
8066   {
8067     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
8068   };
8069 
8070   template <>
8071   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
8072   {
8073     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
8074   };
8075 
8076 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8077   template <>
8078   struct CppType<VkCommandPool, VK_NULL_HANDLE>
8079   {
8080     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
8081   };
8082 #endif
8083 
8084   template <>
8085   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
8086   {
8087     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8088   };
8089 
8090   class PipelineCache
8091   {
8092   public:
8093     using CType      = VkPipelineCache;
8094     using NativeType = VkPipelineCache;
8095 
8096     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
8097     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8098       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
8099 
8100   public:
PipelineCache()8101     PipelineCache() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8102     PipelineCache( PipelineCache const & rhs )             = default;
8103     PipelineCache & operator=( PipelineCache const & rhs ) = default;
8104 
8105 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8106     PipelineCache( PipelineCache && rhs )             = default;
8107     PipelineCache & operator=( PipelineCache && rhs ) = default;
8108 #else
PipelineCache(PipelineCache && rhs)8109     PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) {}
8110 
operator =(PipelineCache && rhs)8111     PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
8112     {
8113       m_pipelineCache = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} );
8114       return *this;
8115     }
8116 #endif
8117 
PipelineCache(std::nullptr_t)8118     VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8119 
PipelineCache(VkPipelineCache pipelineCache)8120     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
8121 
8122 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipelineCache pipelineCache)8123     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
8124     {
8125       m_pipelineCache = pipelineCache;
8126       return *this;
8127     }
8128 #endif
8129 
operator =(std::nullptr_t)8130     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8131     {
8132       m_pipelineCache = {};
8133       return *this;
8134     }
8135 
8136 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8137     auto operator<=>( PipelineCache const & ) const = default;
8138 #else
operator ==(PipelineCache const & rhs) const8139     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
8140     {
8141       return m_pipelineCache == rhs.m_pipelineCache;
8142     }
8143 
operator !=(PipelineCache const & rhs) const8144     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
8145     {
8146       return m_pipelineCache != rhs.m_pipelineCache;
8147     }
8148 
operator <(PipelineCache const & rhs) const8149     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
8150     {
8151       return m_pipelineCache < rhs.m_pipelineCache;
8152     }
8153 #endif
8154 
operator VkPipelineCache() const8155     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
8156     {
8157       return m_pipelineCache;
8158     }
8159 
operator bool() const8160     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8161     {
8162       return m_pipelineCache != VK_NULL_HANDLE;
8163     }
8164 
operator !() const8165     bool operator!() const VULKAN_HPP_NOEXCEPT
8166     {
8167       return m_pipelineCache == VK_NULL_HANDLE;
8168     }
8169 
8170   private:
8171     VkPipelineCache m_pipelineCache = {};
8172   };
8173 
8174   template <>
8175   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
8176   {
8177     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
8178   };
8179 
8180   template <>
8181   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
8182   {
8183     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
8184   };
8185 
8186 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8187   template <>
8188   struct CppType<VkPipelineCache, VK_NULL_HANDLE>
8189   {
8190     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
8191   };
8192 #endif
8193 
8194   template <>
8195   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
8196   {
8197     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8198   };
8199 
8200   class CuFunctionNVX
8201   {
8202   public:
8203     using CType      = VkCuFunctionNVX;
8204     using NativeType = VkCuFunctionNVX;
8205 
8206     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
8207     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8208       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
8209 
8210   public:
CuFunctionNVX()8211     CuFunctionNVX() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8212     CuFunctionNVX( CuFunctionNVX const & rhs )             = default;
8213     CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default;
8214 
8215 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8216     CuFunctionNVX( CuFunctionNVX && rhs )             = default;
8217     CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default;
8218 #else
CuFunctionNVX(CuFunctionNVX && rhs)8219     CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) ) {}
8220 
operator =(CuFunctionNVX && rhs)8221     CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
8222     {
8223       m_cuFunctionNVX = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} );
8224       return *this;
8225     }
8226 #endif
8227 
CuFunctionNVX(std::nullptr_t)8228     VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8229 
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)8230     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
8231 
8232 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCuFunctionNVX cuFunctionNVX)8233     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
8234     {
8235       m_cuFunctionNVX = cuFunctionNVX;
8236       return *this;
8237     }
8238 #endif
8239 
operator =(std::nullptr_t)8240     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8241     {
8242       m_cuFunctionNVX = {};
8243       return *this;
8244     }
8245 
8246 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8247     auto operator<=>( CuFunctionNVX const & ) const = default;
8248 #else
operator ==(CuFunctionNVX const & rhs) const8249     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
8250     {
8251       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
8252     }
8253 
operator !=(CuFunctionNVX const & rhs) const8254     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
8255     {
8256       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
8257     }
8258 
operator <(CuFunctionNVX const & rhs) const8259     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
8260     {
8261       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
8262     }
8263 #endif
8264 
operator VkCuFunctionNVX() const8265     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
8266     {
8267       return m_cuFunctionNVX;
8268     }
8269 
operator bool() const8270     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8271     {
8272       return m_cuFunctionNVX != VK_NULL_HANDLE;
8273     }
8274 
operator !() const8275     bool operator!() const VULKAN_HPP_NOEXCEPT
8276     {
8277       return m_cuFunctionNVX == VK_NULL_HANDLE;
8278     }
8279 
8280   private:
8281     VkCuFunctionNVX m_cuFunctionNVX = {};
8282   };
8283 
8284   template <>
8285   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
8286   {
8287     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
8288   };
8289 
8290   template <>
8291   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
8292   {
8293     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
8294   };
8295 
8296 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8297   template <>
8298   struct CppType<VkCuFunctionNVX, VK_NULL_HANDLE>
8299   {
8300     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
8301   };
8302 #endif
8303 
8304   template <>
8305   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
8306   {
8307     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8308   };
8309 
8310   class CuModuleNVX
8311   {
8312   public:
8313     using CType      = VkCuModuleNVX;
8314     using NativeType = VkCuModuleNVX;
8315 
8316     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
8317     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8318       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
8319 
8320   public:
CuModuleNVX()8321     CuModuleNVX() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8322     CuModuleNVX( CuModuleNVX const & rhs )             = default;
8323     CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default;
8324 
8325 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8326     CuModuleNVX( CuModuleNVX && rhs )             = default;
8327     CuModuleNVX & operator=( CuModuleNVX && rhs ) = default;
8328 #else
CuModuleNVX(CuModuleNVX && rhs)8329     CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) ) {}
8330 
operator =(CuModuleNVX && rhs)8331     CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
8332     {
8333       m_cuModuleNVX = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} );
8334       return *this;
8335     }
8336 #endif
8337 
CuModuleNVX(std::nullptr_t)8338     VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8339 
CuModuleNVX(VkCuModuleNVX cuModuleNVX)8340     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
8341 
8342 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCuModuleNVX cuModuleNVX)8343     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
8344     {
8345       m_cuModuleNVX = cuModuleNVX;
8346       return *this;
8347     }
8348 #endif
8349 
operator =(std::nullptr_t)8350     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8351     {
8352       m_cuModuleNVX = {};
8353       return *this;
8354     }
8355 
8356 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8357     auto operator<=>( CuModuleNVX const & ) const = default;
8358 #else
operator ==(CuModuleNVX const & rhs) const8359     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
8360     {
8361       return m_cuModuleNVX == rhs.m_cuModuleNVX;
8362     }
8363 
operator !=(CuModuleNVX const & rhs) const8364     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
8365     {
8366       return m_cuModuleNVX != rhs.m_cuModuleNVX;
8367     }
8368 
operator <(CuModuleNVX const & rhs) const8369     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
8370     {
8371       return m_cuModuleNVX < rhs.m_cuModuleNVX;
8372     }
8373 #endif
8374 
operator VkCuModuleNVX() const8375     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
8376     {
8377       return m_cuModuleNVX;
8378     }
8379 
operator bool() const8380     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8381     {
8382       return m_cuModuleNVX != VK_NULL_HANDLE;
8383     }
8384 
operator !() const8385     bool operator!() const VULKAN_HPP_NOEXCEPT
8386     {
8387       return m_cuModuleNVX == VK_NULL_HANDLE;
8388     }
8389 
8390   private:
8391     VkCuModuleNVX m_cuModuleNVX = {};
8392   };
8393 
8394   template <>
8395   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
8396   {
8397     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
8398   };
8399 
8400   template <>
8401   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
8402   {
8403     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
8404   };
8405 
8406 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8407   template <>
8408   struct CppType<VkCuModuleNVX, VK_NULL_HANDLE>
8409   {
8410     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
8411   };
8412 #endif
8413 
8414   template <>
8415   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
8416   {
8417     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8418   };
8419 
8420 #if defined( VK_ENABLE_BETA_EXTENSIONS )
8421   class CudaFunctionNV
8422   {
8423   public:
8424     using CType      = VkCudaFunctionNV;
8425     using NativeType = VkCudaFunctionNV;
8426 
8427     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;
8428     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8429       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;
8430 
8431   public:
CudaFunctionNV()8432     CudaFunctionNV() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8433     CudaFunctionNV( CudaFunctionNV const & rhs )             = default;
8434     CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default;
8435 
8436 #  if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8437     CudaFunctionNV( CudaFunctionNV && rhs )             = default;
8438     CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default;
8439 #  else
CudaFunctionNV(CudaFunctionNV && rhs)8440     CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} ) ) {}
8441 
operator =(CudaFunctionNV && rhs)8442     CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT
8443     {
8444       m_cudaFunctionNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} );
8445       return *this;
8446     }
8447 #  endif
8448 
CudaFunctionNV(std::nullptr_t)8449     VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8450 
CudaFunctionNV(VkCudaFunctionNV cudaFunctionNV)8451     VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
8452 
8453 #  if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCudaFunctionNV cudaFunctionNV)8454     CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
8455     {
8456       m_cudaFunctionNV = cudaFunctionNV;
8457       return *this;
8458     }
8459 #  endif
8460 
operator =(std::nullptr_t)8461     CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8462     {
8463       m_cudaFunctionNV = {};
8464       return *this;
8465     }
8466 
8467 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8468     auto operator<=>( CudaFunctionNV const & ) const = default;
8469 #  else
operator ==(CudaFunctionNV const & rhs) const8470     bool operator==( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8471     {
8472       return m_cudaFunctionNV == rhs.m_cudaFunctionNV;
8473     }
8474 
operator !=(CudaFunctionNV const & rhs) const8475     bool operator!=( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8476     {
8477       return m_cudaFunctionNV != rhs.m_cudaFunctionNV;
8478     }
8479 
operator <(CudaFunctionNV const & rhs) const8480     bool operator<( CudaFunctionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8481     {
8482       return m_cudaFunctionNV < rhs.m_cudaFunctionNV;
8483     }
8484 #  endif
8485 
operator VkCudaFunctionNV() const8486     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT
8487     {
8488       return m_cudaFunctionNV;
8489     }
8490 
operator bool() const8491     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8492     {
8493       return m_cudaFunctionNV != VK_NULL_HANDLE;
8494     }
8495 
operator !() const8496     bool operator!() const VULKAN_HPP_NOEXCEPT
8497     {
8498       return m_cudaFunctionNV == VK_NULL_HANDLE;
8499     }
8500 
8501   private:
8502     VkCudaFunctionNV m_cudaFunctionNV = {};
8503   };
8504 
8505   template <>
8506   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV>
8507   {
8508     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
8509   };
8510 
8511   template <>
8512   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV>
8513   {
8514     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
8515   };
8516 
8517 #  if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8518   template <>
8519   struct CppType<VkCudaFunctionNV, VK_NULL_HANDLE>
8520   {
8521     using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
8522   };
8523 #  endif
8524 
8525   template <>
8526   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>
8527   {
8528     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8529   };
8530 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
8531 
8532 #if defined( VK_ENABLE_BETA_EXTENSIONS )
8533   class CudaModuleNV
8534   {
8535   public:
8536     using CType      = VkCudaModuleNV;
8537     using NativeType = VkCudaModuleNV;
8538 
8539     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;
8540     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8541       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;
8542 
8543   public:
CudaModuleNV()8544     CudaModuleNV() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8545     CudaModuleNV( CudaModuleNV const & rhs )             = default;
8546     CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default;
8547 
8548 #  if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8549     CudaModuleNV( CudaModuleNV && rhs )             = default;
8550     CudaModuleNV & operator=( CudaModuleNV && rhs ) = default;
8551 #  else
CudaModuleNV(CudaModuleNV && rhs)8552     CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} ) ) {}
8553 
operator =(CudaModuleNV && rhs)8554     CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT
8555     {
8556       m_cudaModuleNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} );
8557       return *this;
8558     }
8559 #  endif
8560 
CudaModuleNV(std::nullptr_t)8561     VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8562 
CudaModuleNV(VkCudaModuleNV cudaModuleNV)8563     VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
8564 
8565 #  if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkCudaModuleNV cudaModuleNV)8566     CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
8567     {
8568       m_cudaModuleNV = cudaModuleNV;
8569       return *this;
8570     }
8571 #  endif
8572 
operator =(std::nullptr_t)8573     CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8574     {
8575       m_cudaModuleNV = {};
8576       return *this;
8577     }
8578 
8579 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8580     auto operator<=>( CudaModuleNV const & ) const = default;
8581 #  else
operator ==(CudaModuleNV const & rhs) const8582     bool operator==( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8583     {
8584       return m_cudaModuleNV == rhs.m_cudaModuleNV;
8585     }
8586 
operator !=(CudaModuleNV const & rhs) const8587     bool operator!=( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8588     {
8589       return m_cudaModuleNV != rhs.m_cudaModuleNV;
8590     }
8591 
operator <(CudaModuleNV const & rhs) const8592     bool operator<( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
8593     {
8594       return m_cudaModuleNV < rhs.m_cudaModuleNV;
8595     }
8596 #  endif
8597 
operator VkCudaModuleNV() const8598     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT
8599     {
8600       return m_cudaModuleNV;
8601     }
8602 
operator bool() const8603     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8604     {
8605       return m_cudaModuleNV != VK_NULL_HANDLE;
8606     }
8607 
operator !() const8608     bool operator!() const VULKAN_HPP_NOEXCEPT
8609     {
8610       return m_cudaModuleNV == VK_NULL_HANDLE;
8611     }
8612 
8613   private:
8614     VkCudaModuleNV m_cudaModuleNV = {};
8615   };
8616 
8617   template <>
8618   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV>
8619   {
8620     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
8621   };
8622 
8623   template <>
8624   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV>
8625   {
8626     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
8627   };
8628 
8629 #  if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8630   template <>
8631   struct CppType<VkCudaModuleNV, VK_NULL_HANDLE>
8632   {
8633     using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
8634   };
8635 #  endif
8636 
8637   template <>
8638   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaModuleNV>
8639   {
8640     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8641   };
8642 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
8643 
8644   class DescriptorPool
8645   {
8646   public:
8647     using CType      = VkDescriptorPool;
8648     using NativeType = VkDescriptorPool;
8649 
8650     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
8651     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8652       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
8653 
8654   public:
DescriptorPool()8655     DescriptorPool() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8656     DescriptorPool( DescriptorPool const & rhs )             = default;
8657     DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
8658 
8659 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8660     DescriptorPool( DescriptorPool && rhs )             = default;
8661     DescriptorPool & operator=( DescriptorPool && rhs ) = default;
8662 #else
DescriptorPool(DescriptorPool && rhs)8663     DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) {}
8664 
operator =(DescriptorPool && rhs)8665     DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
8666     {
8667       m_descriptorPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
8668       return *this;
8669     }
8670 #endif
8671 
DescriptorPool(std::nullptr_t)8672     VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8673 
DescriptorPool(VkDescriptorPool descriptorPool)8674     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
8675 
8676 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorPool descriptorPool)8677     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
8678     {
8679       m_descriptorPool = descriptorPool;
8680       return *this;
8681     }
8682 #endif
8683 
operator =(std::nullptr_t)8684     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8685     {
8686       m_descriptorPool = {};
8687       return *this;
8688     }
8689 
8690 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8691     auto operator<=>( DescriptorPool const & ) const = default;
8692 #else
operator ==(DescriptorPool const & rhs) const8693     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8694     {
8695       return m_descriptorPool == rhs.m_descriptorPool;
8696     }
8697 
operator !=(DescriptorPool const & rhs) const8698     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8699     {
8700       return m_descriptorPool != rhs.m_descriptorPool;
8701     }
8702 
operator <(DescriptorPool const & rhs) const8703     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
8704     {
8705       return m_descriptorPool < rhs.m_descriptorPool;
8706     }
8707 #endif
8708 
operator VkDescriptorPool() const8709     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
8710     {
8711       return m_descriptorPool;
8712     }
8713 
operator bool() const8714     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8715     {
8716       return m_descriptorPool != VK_NULL_HANDLE;
8717     }
8718 
operator !() const8719     bool operator!() const VULKAN_HPP_NOEXCEPT
8720     {
8721       return m_descriptorPool == VK_NULL_HANDLE;
8722     }
8723 
8724   private:
8725     VkDescriptorPool m_descriptorPool = {};
8726   };
8727 
8728   template <>
8729   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
8730   {
8731     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
8732   };
8733 
8734   template <>
8735   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
8736   {
8737     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
8738   };
8739 
8740 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8741   template <>
8742   struct CppType<VkDescriptorPool, VK_NULL_HANDLE>
8743   {
8744     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
8745   };
8746 #endif
8747 
8748   template <>
8749   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
8750   {
8751     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8752   };
8753 
8754   class DescriptorSetLayout
8755   {
8756   public:
8757     using CType      = VkDescriptorSetLayout;
8758     using NativeType = VkDescriptorSetLayout;
8759 
8760     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
8761     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8762       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
8763 
8764   public:
DescriptorSetLayout()8765     DescriptorSetLayout() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8766     DescriptorSetLayout( DescriptorSetLayout const & rhs )             = default;
8767     DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
8768 
8769 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8770     DescriptorSetLayout( DescriptorSetLayout && rhs )             = default;
8771     DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;
8772 #else
DescriptorSetLayout(DescriptorSetLayout && rhs)8773     DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
8774       : m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )
8775     {
8776     }
8777 
operator =(DescriptorSetLayout && rhs)8778     DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
8779     {
8780       m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );
8781       return *this;
8782     }
8783 #endif
8784 
DescriptorSetLayout(std::nullptr_t)8785     VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8786 
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)8787     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
8788       : m_descriptorSetLayout( descriptorSetLayout )
8789     {
8790     }
8791 
8792 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDescriptorSetLayout descriptorSetLayout)8793     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
8794     {
8795       m_descriptorSetLayout = descriptorSetLayout;
8796       return *this;
8797     }
8798 #endif
8799 
operator =(std::nullptr_t)8800     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8801     {
8802       m_descriptorSetLayout = {};
8803       return *this;
8804     }
8805 
8806 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8807     auto operator<=>( DescriptorSetLayout const & ) const = default;
8808 #else
operator ==(DescriptorSetLayout const & rhs) const8809     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
8810     {
8811       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
8812     }
8813 
operator !=(DescriptorSetLayout const & rhs) const8814     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
8815     {
8816       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
8817     }
8818 
operator <(DescriptorSetLayout const & rhs) const8819     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
8820     {
8821       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
8822     }
8823 #endif
8824 
operator VkDescriptorSetLayout() const8825     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
8826     {
8827       return m_descriptorSetLayout;
8828     }
8829 
operator bool() const8830     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8831     {
8832       return m_descriptorSetLayout != VK_NULL_HANDLE;
8833     }
8834 
operator !() const8835     bool operator!() const VULKAN_HPP_NOEXCEPT
8836     {
8837       return m_descriptorSetLayout == VK_NULL_HANDLE;
8838     }
8839 
8840   private:
8841     VkDescriptorSetLayout m_descriptorSetLayout = {};
8842   };
8843 
8844   template <>
8845   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
8846   {
8847     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
8848   };
8849 
8850   template <>
8851   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
8852   {
8853     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
8854   };
8855 
8856 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8857   template <>
8858   struct CppType<VkDescriptorSetLayout, VK_NULL_HANDLE>
8859   {
8860     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
8861   };
8862 #endif
8863 
8864   template <>
8865   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
8866   {
8867     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8868   };
8869 
8870   class Framebuffer
8871   {
8872   public:
8873     using CType      = VkFramebuffer;
8874     using NativeType = VkFramebuffer;
8875 
8876     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
8877     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8878       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
8879 
8880   public:
Framebuffer()8881     Framebuffer() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8882     Framebuffer( Framebuffer const & rhs )             = default;
8883     Framebuffer & operator=( Framebuffer const & rhs ) = default;
8884 
8885 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8886     Framebuffer( Framebuffer && rhs )             = default;
8887     Framebuffer & operator=( Framebuffer && rhs ) = default;
8888 #else
Framebuffer(Framebuffer && rhs)8889     Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) {}
8890 
operator =(Framebuffer && rhs)8891     Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
8892     {
8893       m_framebuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} );
8894       return *this;
8895     }
8896 #endif
8897 
Framebuffer(std::nullptr_t)8898     VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
8899 
Framebuffer(VkFramebuffer framebuffer)8900     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
8901 
8902 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkFramebuffer framebuffer)8903     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
8904     {
8905       m_framebuffer = framebuffer;
8906       return *this;
8907     }
8908 #endif
8909 
operator =(std::nullptr_t)8910     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
8911     {
8912       m_framebuffer = {};
8913       return *this;
8914     }
8915 
8916 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8917     auto operator<=>( Framebuffer const & ) const = default;
8918 #else
operator ==(Framebuffer const & rhs) const8919     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
8920     {
8921       return m_framebuffer == rhs.m_framebuffer;
8922     }
8923 
operator !=(Framebuffer const & rhs) const8924     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
8925     {
8926       return m_framebuffer != rhs.m_framebuffer;
8927     }
8928 
operator <(Framebuffer const & rhs) const8929     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
8930     {
8931       return m_framebuffer < rhs.m_framebuffer;
8932     }
8933 #endif
8934 
operator VkFramebuffer() const8935     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
8936     {
8937       return m_framebuffer;
8938     }
8939 
operator bool() const8940     explicit operator bool() const VULKAN_HPP_NOEXCEPT
8941     {
8942       return m_framebuffer != VK_NULL_HANDLE;
8943     }
8944 
operator !() const8945     bool operator!() const VULKAN_HPP_NOEXCEPT
8946     {
8947       return m_framebuffer == VK_NULL_HANDLE;
8948     }
8949 
8950   private:
8951     VkFramebuffer m_framebuffer = {};
8952   };
8953 
8954   template <>
8955   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
8956   {
8957     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
8958   };
8959 
8960   template <>
8961   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
8962   {
8963     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
8964   };
8965 
8966 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
8967   template <>
8968   struct CppType<VkFramebuffer, VK_NULL_HANDLE>
8969   {
8970     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
8971   };
8972 #endif
8973 
8974   template <>
8975   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
8976   {
8977     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8978   };
8979 
8980   class IndirectCommandsLayoutNV
8981   {
8982   public:
8983     using CType      = VkIndirectCommandsLayoutNV;
8984     using NativeType = VkIndirectCommandsLayoutNV;
8985 
8986     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
8987     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
8988       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8989 
8990   public:
IndirectCommandsLayoutNV()8991     IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
8992     IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs )             = default;
8993     IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default;
8994 
8995 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
8996     IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs )             = default;
8997     IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default;
8998 #else
IndirectCommandsLayoutNV(IndirectCommandsLayoutNV && rhs)8999     IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
9000       : m_indirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ) )
9001     {
9002     }
9003 
operator =(IndirectCommandsLayoutNV && rhs)9004     IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
9005     {
9006       m_indirectCommandsLayoutNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} );
9007       return *this;
9008     }
9009 #endif
9010 
IndirectCommandsLayoutNV(std::nullptr_t)9011     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9012 
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)9013     VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
9014       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
9015     {
9016     }
9017 
9018 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)9019     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
9020     {
9021       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
9022       return *this;
9023     }
9024 #endif
9025 
operator =(std::nullptr_t)9026     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9027     {
9028       m_indirectCommandsLayoutNV = {};
9029       return *this;
9030     }
9031 
9032 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9033     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
9034 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const9035     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
9036     {
9037       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
9038     }
9039 
operator !=(IndirectCommandsLayoutNV const & rhs) const9040     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
9041     {
9042       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
9043     }
9044 
operator <(IndirectCommandsLayoutNV const & rhs) const9045     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
9046     {
9047       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
9048     }
9049 #endif
9050 
operator VkIndirectCommandsLayoutNV() const9051     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
9052     {
9053       return m_indirectCommandsLayoutNV;
9054     }
9055 
operator bool() const9056     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9057     {
9058       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
9059     }
9060 
operator !() const9061     bool operator!() const VULKAN_HPP_NOEXCEPT
9062     {
9063       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
9064     }
9065 
9066   private:
9067     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
9068   };
9069 
9070   template <>
9071   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
9072   {
9073     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
9074   };
9075 
9076 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9077   template <>
9078   struct CppType<VkIndirectCommandsLayoutNV, VK_NULL_HANDLE>
9079   {
9080     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
9081   };
9082 #endif
9083 
9084   template <>
9085   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
9086   {
9087     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9088   };
9089 
9090   class PrivateDataSlot
9091   {
9092   public:
9093     using CType      = VkPrivateDataSlot;
9094     using NativeType = VkPrivateDataSlot;
9095 
9096     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
9097     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9098       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9099 
9100   public:
PrivateDataSlot()9101     PrivateDataSlot() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9102     PrivateDataSlot( PrivateDataSlot const & rhs )             = default;
9103     PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
9104 
9105 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9106     PrivateDataSlot( PrivateDataSlot && rhs )             = default;
9107     PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;
9108 #else
PrivateDataSlot(PrivateDataSlot && rhs)9109     PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) {}
9110 
operator =(PrivateDataSlot && rhs)9111     PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
9112     {
9113       m_privateDataSlot = VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );
9114       return *this;
9115     }
9116 #endif
9117 
PrivateDataSlot(std::nullptr_t)9118     VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9119 
PrivateDataSlot(VkPrivateDataSlot privateDataSlot)9120     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
9121 
9122 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPrivateDataSlot privateDataSlot)9123     PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
9124     {
9125       m_privateDataSlot = privateDataSlot;
9126       return *this;
9127     }
9128 #endif
9129 
operator =(std::nullptr_t)9130     PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9131     {
9132       m_privateDataSlot = {};
9133       return *this;
9134     }
9135 
9136 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9137     auto operator<=>( PrivateDataSlot const & ) const = default;
9138 #else
operator ==(PrivateDataSlot const & rhs) const9139     bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
9140     {
9141       return m_privateDataSlot == rhs.m_privateDataSlot;
9142     }
9143 
operator !=(PrivateDataSlot const & rhs) const9144     bool operator!=( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
9145     {
9146       return m_privateDataSlot != rhs.m_privateDataSlot;
9147     }
9148 
operator <(PrivateDataSlot const & rhs) const9149     bool operator<( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
9150     {
9151       return m_privateDataSlot < rhs.m_privateDataSlot;
9152     }
9153 #endif
9154 
operator VkPrivateDataSlot() const9155     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
9156     {
9157       return m_privateDataSlot;
9158     }
9159 
operator bool() const9160     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9161     {
9162       return m_privateDataSlot != VK_NULL_HANDLE;
9163     }
9164 
operator !() const9165     bool operator!() const VULKAN_HPP_NOEXCEPT
9166     {
9167       return m_privateDataSlot == VK_NULL_HANDLE;
9168     }
9169 
9170   private:
9171     VkPrivateDataSlot m_privateDataSlot = {};
9172   };
9173 
9174   template <>
9175   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
9176   {
9177     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
9178   };
9179 
9180 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9181   template <>
9182   struct CppType<VkPrivateDataSlot, VK_NULL_HANDLE>
9183   {
9184     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
9185   };
9186 #endif
9187 
9188   template <>
9189   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
9190   {
9191     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9192   };
9193 
9194   using PrivateDataSlotEXT = PrivateDataSlot;
9195 
9196   class RenderPass
9197   {
9198   public:
9199     using CType      = VkRenderPass;
9200     using NativeType = VkRenderPass;
9201 
9202     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
9203     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9204       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
9205 
9206   public:
RenderPass()9207     RenderPass() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9208     RenderPass( RenderPass const & rhs )             = default;
9209     RenderPass & operator=( RenderPass const & rhs ) = default;
9210 
9211 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9212     RenderPass( RenderPass && rhs )             = default;
9213     RenderPass & operator=( RenderPass && rhs ) = default;
9214 #else
RenderPass(RenderPass && rhs)9215     RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) {}
9216 
operator =(RenderPass && rhs)9217     RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
9218     {
9219       m_renderPass = VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} );
9220       return *this;
9221     }
9222 #endif
9223 
RenderPass(std::nullptr_t)9224     VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9225 
RenderPass(VkRenderPass renderPass)9226     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
9227 
9228 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkRenderPass renderPass)9229     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
9230     {
9231       m_renderPass = renderPass;
9232       return *this;
9233     }
9234 #endif
9235 
operator =(std::nullptr_t)9236     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9237     {
9238       m_renderPass = {};
9239       return *this;
9240     }
9241 
9242 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9243     auto operator<=>( RenderPass const & ) const = default;
9244 #else
operator ==(RenderPass const & rhs) const9245     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
9246     {
9247       return m_renderPass == rhs.m_renderPass;
9248     }
9249 
operator !=(RenderPass const & rhs) const9250     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
9251     {
9252       return m_renderPass != rhs.m_renderPass;
9253     }
9254 
operator <(RenderPass const & rhs) const9255     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
9256     {
9257       return m_renderPass < rhs.m_renderPass;
9258     }
9259 #endif
9260 
operator VkRenderPass() const9261     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
9262     {
9263       return m_renderPass;
9264     }
9265 
operator bool() const9266     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9267     {
9268       return m_renderPass != VK_NULL_HANDLE;
9269     }
9270 
operator !() const9271     bool operator!() const VULKAN_HPP_NOEXCEPT
9272     {
9273       return m_renderPass == VK_NULL_HANDLE;
9274     }
9275 
9276   private:
9277     VkRenderPass m_renderPass = {};
9278   };
9279 
9280   template <>
9281   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
9282   {
9283     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
9284   };
9285 
9286   template <>
9287   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
9288   {
9289     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
9290   };
9291 
9292 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9293   template <>
9294   struct CppType<VkRenderPass, VK_NULL_HANDLE>
9295   {
9296     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
9297   };
9298 #endif
9299 
9300   template <>
9301   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
9302   {
9303     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9304   };
9305 
9306   class Sampler
9307   {
9308   public:
9309     using CType      = VkSampler;
9310     using NativeType = VkSampler;
9311 
9312     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
9313     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9314       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
9315 
9316   public:
Sampler()9317     Sampler() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9318     Sampler( Sampler const & rhs )             = default;
9319     Sampler & operator=( Sampler const & rhs ) = default;
9320 
9321 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9322     Sampler( Sampler && rhs )             = default;
9323     Sampler & operator=( Sampler && rhs ) = default;
9324 #else
Sampler(Sampler && rhs)9325     Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} ) ) {}
9326 
operator =(Sampler && rhs)9327     Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
9328     {
9329       m_sampler = VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} );
9330       return *this;
9331     }
9332 #endif
9333 
Sampler(std::nullptr_t)9334     VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9335 
Sampler(VkSampler sampler)9336     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
9337 
9338 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSampler sampler)9339     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
9340     {
9341       m_sampler = sampler;
9342       return *this;
9343     }
9344 #endif
9345 
operator =(std::nullptr_t)9346     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9347     {
9348       m_sampler = {};
9349       return *this;
9350     }
9351 
9352 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9353     auto operator<=>( Sampler const & ) const = default;
9354 #else
operator ==(Sampler const & rhs) const9355     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
9356     {
9357       return m_sampler == rhs.m_sampler;
9358     }
9359 
operator !=(Sampler const & rhs) const9360     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
9361     {
9362       return m_sampler != rhs.m_sampler;
9363     }
9364 
operator <(Sampler const & rhs) const9365     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
9366     {
9367       return m_sampler < rhs.m_sampler;
9368     }
9369 #endif
9370 
operator VkSampler() const9371     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
9372     {
9373       return m_sampler;
9374     }
9375 
operator bool() const9376     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9377     {
9378       return m_sampler != VK_NULL_HANDLE;
9379     }
9380 
operator !() const9381     bool operator!() const VULKAN_HPP_NOEXCEPT
9382     {
9383       return m_sampler == VK_NULL_HANDLE;
9384     }
9385 
9386   private:
9387     VkSampler m_sampler = {};
9388   };
9389 
9390   template <>
9391   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
9392   {
9393     using Type = VULKAN_HPP_NAMESPACE::Sampler;
9394   };
9395 
9396   template <>
9397   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
9398   {
9399     using Type = VULKAN_HPP_NAMESPACE::Sampler;
9400   };
9401 
9402 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9403   template <>
9404   struct CppType<VkSampler, VK_NULL_HANDLE>
9405   {
9406     using Type = VULKAN_HPP_NAMESPACE::Sampler;
9407   };
9408 #endif
9409 
9410   template <>
9411   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
9412   {
9413     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9414   };
9415 
9416   class SamplerYcbcrConversion
9417   {
9418   public:
9419     using CType      = VkSamplerYcbcrConversion;
9420     using NativeType = VkSamplerYcbcrConversion;
9421 
9422     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
9423     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9424       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
9425 
9426   public:
SamplerYcbcrConversion()9427     SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9428     SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs )             = default;
9429     SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
9430 
9431 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9432     SamplerYcbcrConversion( SamplerYcbcrConversion && rhs )             = default;
9433     SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;
9434 #else
SamplerYcbcrConversion(SamplerYcbcrConversion && rhs)9435     SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
9436       : m_samplerYcbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) )
9437     {
9438     }
9439 
operator =(SamplerYcbcrConversion && rhs)9440     SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
9441     {
9442       m_samplerYcbcrConversion = VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} );
9443       return *this;
9444     }
9445 #endif
9446 
SamplerYcbcrConversion(std::nullptr_t)9447     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9448 
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)9449     VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
9450       : m_samplerYcbcrConversion( samplerYcbcrConversion )
9451     {
9452     }
9453 
9454 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)9455     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
9456     {
9457       m_samplerYcbcrConversion = samplerYcbcrConversion;
9458       return *this;
9459     }
9460 #endif
9461 
operator =(std::nullptr_t)9462     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9463     {
9464       m_samplerYcbcrConversion = {};
9465       return *this;
9466     }
9467 
9468 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9469     auto operator<=>( SamplerYcbcrConversion const & ) const = default;
9470 #else
operator ==(SamplerYcbcrConversion const & rhs) const9471     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
9472     {
9473       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
9474     }
9475 
operator !=(SamplerYcbcrConversion const & rhs) const9476     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
9477     {
9478       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
9479     }
9480 
operator <(SamplerYcbcrConversion const & rhs) const9481     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
9482     {
9483       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
9484     }
9485 #endif
9486 
operator VkSamplerYcbcrConversion() const9487     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
9488     {
9489       return m_samplerYcbcrConversion;
9490     }
9491 
operator bool() const9492     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9493     {
9494       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
9495     }
9496 
operator !() const9497     bool operator!() const VULKAN_HPP_NOEXCEPT
9498     {
9499       return m_samplerYcbcrConversion == VK_NULL_HANDLE;
9500     }
9501 
9502   private:
9503     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
9504   };
9505 
9506   template <>
9507   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
9508   {
9509     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
9510   };
9511 
9512   template <>
9513   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
9514   {
9515     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
9516   };
9517 
9518 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9519   template <>
9520   struct CppType<VkSamplerYcbcrConversion, VK_NULL_HANDLE>
9521   {
9522     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
9523   };
9524 #endif
9525 
9526   template <>
9527   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
9528   {
9529     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9530   };
9531 
9532   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
9533 
9534   class ShaderModule
9535   {
9536   public:
9537     using CType      = VkShaderModule;
9538     using NativeType = VkShaderModule;
9539 
9540     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
9541     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9542       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
9543 
9544   public:
ShaderModule()9545     ShaderModule() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9546     ShaderModule( ShaderModule const & rhs )             = default;
9547     ShaderModule & operator=( ShaderModule const & rhs ) = default;
9548 
9549 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9550     ShaderModule( ShaderModule && rhs )             = default;
9551     ShaderModule & operator=( ShaderModule && rhs ) = default;
9552 #else
ShaderModule(ShaderModule && rhs)9553     ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) {}
9554 
operator =(ShaderModule && rhs)9555     ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
9556     {
9557       m_shaderModule = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} );
9558       return *this;
9559     }
9560 #endif
9561 
ShaderModule(std::nullptr_t)9562     VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9563 
ShaderModule(VkShaderModule shaderModule)9564     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
9565 
9566 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkShaderModule shaderModule)9567     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
9568     {
9569       m_shaderModule = shaderModule;
9570       return *this;
9571     }
9572 #endif
9573 
operator =(std::nullptr_t)9574     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9575     {
9576       m_shaderModule = {};
9577       return *this;
9578     }
9579 
9580 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9581     auto operator<=>( ShaderModule const & ) const = default;
9582 #else
operator ==(ShaderModule const & rhs) const9583     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
9584     {
9585       return m_shaderModule == rhs.m_shaderModule;
9586     }
9587 
operator !=(ShaderModule const & rhs) const9588     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
9589     {
9590       return m_shaderModule != rhs.m_shaderModule;
9591     }
9592 
operator <(ShaderModule const & rhs) const9593     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
9594     {
9595       return m_shaderModule < rhs.m_shaderModule;
9596     }
9597 #endif
9598 
operator VkShaderModule() const9599     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
9600     {
9601       return m_shaderModule;
9602     }
9603 
operator bool() const9604     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9605     {
9606       return m_shaderModule != VK_NULL_HANDLE;
9607     }
9608 
operator !() const9609     bool operator!() const VULKAN_HPP_NOEXCEPT
9610     {
9611       return m_shaderModule == VK_NULL_HANDLE;
9612     }
9613 
9614   private:
9615     VkShaderModule m_shaderModule = {};
9616   };
9617 
9618   template <>
9619   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
9620   {
9621     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
9622   };
9623 
9624   template <>
9625   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
9626   {
9627     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
9628   };
9629 
9630 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9631   template <>
9632   struct CppType<VkShaderModule, VK_NULL_HANDLE>
9633   {
9634     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
9635   };
9636 #endif
9637 
9638   template <>
9639   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
9640   {
9641     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9642   };
9643 
9644   class ValidationCacheEXT
9645   {
9646   public:
9647     using CType      = VkValidationCacheEXT;
9648     using NativeType = VkValidationCacheEXT;
9649 
9650     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
9651     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9652       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
9653 
9654   public:
ValidationCacheEXT()9655     ValidationCacheEXT() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9656     ValidationCacheEXT( ValidationCacheEXT const & rhs )             = default;
9657     ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default;
9658 
9659 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9660     ValidationCacheEXT( ValidationCacheEXT && rhs )             = default;
9661     ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default;
9662 #else
ValidationCacheEXT(ValidationCacheEXT && rhs)9663     ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} ) )
9664     {
9665     }
9666 
operator =(ValidationCacheEXT && rhs)9667     ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
9668     {
9669       m_validationCacheEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} );
9670       return *this;
9671     }
9672 #endif
9673 
ValidationCacheEXT(std::nullptr_t)9674     VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9675 
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)9676     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
9677     {
9678     }
9679 
9680 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkValidationCacheEXT validationCacheEXT)9681     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
9682     {
9683       m_validationCacheEXT = validationCacheEXT;
9684       return *this;
9685     }
9686 #endif
9687 
operator =(std::nullptr_t)9688     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9689     {
9690       m_validationCacheEXT = {};
9691       return *this;
9692     }
9693 
9694 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9695     auto operator<=>( ValidationCacheEXT const & ) const = default;
9696 #else
operator ==(ValidationCacheEXT const & rhs) const9697     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
9698     {
9699       return m_validationCacheEXT == rhs.m_validationCacheEXT;
9700     }
9701 
operator !=(ValidationCacheEXT const & rhs) const9702     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
9703     {
9704       return m_validationCacheEXT != rhs.m_validationCacheEXT;
9705     }
9706 
operator <(ValidationCacheEXT const & rhs) const9707     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
9708     {
9709       return m_validationCacheEXT < rhs.m_validationCacheEXT;
9710     }
9711 #endif
9712 
operator VkValidationCacheEXT() const9713     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
9714     {
9715       return m_validationCacheEXT;
9716     }
9717 
operator bool() const9718     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9719     {
9720       return m_validationCacheEXT != VK_NULL_HANDLE;
9721     }
9722 
operator !() const9723     bool operator!() const VULKAN_HPP_NOEXCEPT
9724     {
9725       return m_validationCacheEXT == VK_NULL_HANDLE;
9726     }
9727 
9728   private:
9729     VkValidationCacheEXT m_validationCacheEXT = {};
9730   };
9731 
9732   template <>
9733   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
9734   {
9735     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
9736   };
9737 
9738   template <>
9739   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
9740   {
9741     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
9742   };
9743 
9744 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9745   template <>
9746   struct CppType<VkValidationCacheEXT, VK_NULL_HANDLE>
9747   {
9748     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
9749   };
9750 #endif
9751 
9752   template <>
9753   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
9754   {
9755     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9756   };
9757 
9758   class VideoSessionParametersKHR
9759   {
9760   public:
9761     using CType      = VkVideoSessionParametersKHR;
9762     using NativeType = VkVideoSessionParametersKHR;
9763 
9764     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
9765     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9766       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9767 
9768   public:
VideoSessionParametersKHR()9769     VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9770     VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs )             = default;
9771     VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default;
9772 
9773 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9774     VideoSessionParametersKHR( VideoSessionParametersKHR && rhs )             = default;
9775     VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default;
9776 #else
VideoSessionParametersKHR(VideoSessionParametersKHR && rhs)9777     VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
9778       : m_videoSessionParametersKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ) )
9779     {
9780     }
9781 
operator =(VideoSessionParametersKHR && rhs)9782     VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
9783     {
9784       m_videoSessionParametersKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} );
9785       return *this;
9786     }
9787 #endif
9788 
VideoSessionParametersKHR(std::nullptr_t)9789     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9790 
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)9791     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
9792       : m_videoSessionParametersKHR( videoSessionParametersKHR )
9793     {
9794     }
9795 
9796 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)9797     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
9798     {
9799       m_videoSessionParametersKHR = videoSessionParametersKHR;
9800       return *this;
9801     }
9802 #endif
9803 
operator =(std::nullptr_t)9804     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9805     {
9806       m_videoSessionParametersKHR = {};
9807       return *this;
9808     }
9809 
9810 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9811     auto operator<=>( VideoSessionParametersKHR const & ) const = default;
9812 #else
operator ==(VideoSessionParametersKHR const & rhs) const9813     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9814     {
9815       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
9816     }
9817 
operator !=(VideoSessionParametersKHR const & rhs) const9818     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9819     {
9820       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
9821     }
9822 
operator <(VideoSessionParametersKHR const & rhs) const9823     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9824     {
9825       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
9826     }
9827 #endif
9828 
operator VkVideoSessionParametersKHR() const9829     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
9830     {
9831       return m_videoSessionParametersKHR;
9832     }
9833 
operator bool() const9834     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9835     {
9836       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
9837     }
9838 
operator !() const9839     bool operator!() const VULKAN_HPP_NOEXCEPT
9840     {
9841       return m_videoSessionParametersKHR == VK_NULL_HANDLE;
9842     }
9843 
9844   private:
9845     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
9846   };
9847 
9848   template <>
9849   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
9850   {
9851     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
9852   };
9853 
9854 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9855   template <>
9856   struct CppType<VkVideoSessionParametersKHR, VK_NULL_HANDLE>
9857   {
9858     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
9859   };
9860 #endif
9861 
9862   template <>
9863   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
9864   {
9865     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9866   };
9867 
9868   class PipelineBinaryKHR
9869   {
9870   public:
9871     using CType      = VkPipelineBinaryKHR;
9872     using NativeType = VkPipelineBinaryKHR;
9873 
9874     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR;
9875     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9876       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9877 
9878   public:
PipelineBinaryKHR()9879     PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9880     PipelineBinaryKHR( PipelineBinaryKHR const & rhs )             = default;
9881     PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default;
9882 
9883 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9884     PipelineBinaryKHR( PipelineBinaryKHR && rhs )             = default;
9885     PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default;
9886 #else
PipelineBinaryKHR(PipelineBinaryKHR && rhs)9887     PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} ) ) {}
9888 
operator =(PipelineBinaryKHR && rhs)9889     PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT
9890     {
9891       m_pipelineBinaryKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} );
9892       return *this;
9893     }
9894 #endif
9895 
PipelineBinaryKHR(std::nullptr_t)9896     VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
9897 
PipelineBinaryKHR(VkPipelineBinaryKHR pipelineBinaryKHR)9898     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( pipelineBinaryKHR ) {}
9899 
9900 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkPipelineBinaryKHR pipelineBinaryKHR)9901     PipelineBinaryKHR & operator=( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT
9902     {
9903       m_pipelineBinaryKHR = pipelineBinaryKHR;
9904       return *this;
9905     }
9906 #endif
9907 
operator =(std::nullptr_t)9908     PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
9909     {
9910       m_pipelineBinaryKHR = {};
9911       return *this;
9912     }
9913 
9914 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
9915     auto operator<=>( PipelineBinaryKHR const & ) const = default;
9916 #else
operator ==(PipelineBinaryKHR const & rhs) const9917     bool operator==( PipelineBinaryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9918     {
9919       return m_pipelineBinaryKHR == rhs.m_pipelineBinaryKHR;
9920     }
9921 
operator !=(PipelineBinaryKHR const & rhs) const9922     bool operator!=( PipelineBinaryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9923     {
9924       return m_pipelineBinaryKHR != rhs.m_pipelineBinaryKHR;
9925     }
9926 
operator <(PipelineBinaryKHR const & rhs) const9927     bool operator<( PipelineBinaryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
9928     {
9929       return m_pipelineBinaryKHR < rhs.m_pipelineBinaryKHR;
9930     }
9931 #endif
9932 
operator VkPipelineBinaryKHR() const9933     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT
9934     {
9935       return m_pipelineBinaryKHR;
9936     }
9937 
operator bool() const9938     explicit operator bool() const VULKAN_HPP_NOEXCEPT
9939     {
9940       return m_pipelineBinaryKHR != VK_NULL_HANDLE;
9941     }
9942 
operator !() const9943     bool operator!() const VULKAN_HPP_NOEXCEPT
9944     {
9945       return m_pipelineBinaryKHR == VK_NULL_HANDLE;
9946     }
9947 
9948   private:
9949     VkPipelineBinaryKHR m_pipelineBinaryKHR = {};
9950   };
9951 
9952   template <>
9953   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR>
9954   {
9955     using Type = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
9956   };
9957 
9958 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
9959   template <>
9960   struct CppType<VkPipelineBinaryKHR, VK_NULL_HANDLE>
9961   {
9962     using Type = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
9963   };
9964 #endif
9965 
9966   template <>
9967   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>
9968   {
9969     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
9970   };
9971 
9972   class Queue
9973   {
9974   public:
9975     using CType      = VkQueue;
9976     using NativeType = VkQueue;
9977 
9978     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
9979     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
9980       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
9981 
9982   public:
Queue()9983     Queue() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
9984     Queue( Queue const & rhs )             = default;
9985     Queue & operator=( Queue const & rhs ) = default;
9986 
9987 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
9988     Queue( Queue && rhs )             = default;
9989     Queue & operator=( Queue && rhs ) = default;
9990 #else
Queue(Queue && rhs)9991     Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} ) ) {}
9992 
operator =(Queue && rhs)9993     Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT
9994     {
9995       m_queue = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} );
9996       return *this;
9997     }
9998 #endif
9999 
Queue(std::nullptr_t)10000     VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10001 
Queue(VkQueue queue)10002     Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
10003 
operator =(VkQueue queue)10004     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
10005     {
10006       m_queue = queue;
10007       return *this;
10008     }
10009 
operator =(std::nullptr_t)10010     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10011     {
10012       m_queue = {};
10013       return *this;
10014     }
10015 
10016 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
10017     auto operator<=>( Queue const & ) const = default;
10018 #else
operator ==(Queue const & rhs) const10019     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
10020     {
10021       return m_queue == rhs.m_queue;
10022     }
10023 
operator !=(Queue const & rhs) const10024     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
10025     {
10026       return m_queue != rhs.m_queue;
10027     }
10028 
operator <(Queue const & rhs) const10029     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
10030     {
10031       return m_queue < rhs.m_queue;
10032     }
10033 #endif
10034 
10035     //=== VK_VERSION_1_0 ===
10036 
10037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10038     VULKAN_HPP_NODISCARD Result submit( uint32_t                                 submitCount,
10039                                         const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
10040                                         VULKAN_HPP_NAMESPACE::Fence              fence,
10041                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10044     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10045       submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
10046               VULKAN_HPP_NAMESPACE::Fence fence                                                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10047               Dispatch const & d                                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10048 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10049 
10050 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10052     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10053 #else
10054     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10055     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10056 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10057 
10058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10059     VULKAN_HPP_NODISCARD Result bindSparse( uint32_t                                     bindInfoCount,
10060                                             const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
10061                                             VULKAN_HPP_NAMESPACE::Fence                  fence,
10062                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10065     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10066       bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
10067                   VULKAN_HPP_NAMESPACE::Fence fence                                                    VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10068                   Dispatch const & d                                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10069 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10070 
10071     //=== VK_VERSION_1_3 ===
10072 
10073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10074     VULKAN_HPP_NODISCARD Result submit2( uint32_t                                  submitCount,
10075                                          const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
10076                                          VULKAN_HPP_NAMESPACE::Fence               fence,
10077                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10080     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10081       submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
10082                VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10083                Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10084 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10085 
10086     //=== VK_KHR_swapchain ===
10087 
10088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10089     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
10090                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10092     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10093     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,
10094                                                                   Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10095 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10096 
10097     //=== VK_EXT_debug_utils ===
10098 
10099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10100     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
10101                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10103     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10104     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
10105                                   Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10106 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10107 
10108     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10109     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10110 
10111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10112     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
10113                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10116     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
10117                                    Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10118 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10119 
10120     //=== VK_NV_device_diagnostic_checkpoints ===
10121 
10122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10123     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
10124                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
10125                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10126 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10127     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
10128               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10129     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
10130                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10131     template <
10132       typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
10133       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10134       typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>
10135     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
10136       getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10137 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10138 
10139     //=== VK_INTEL_performance_query ===
10140 
10141 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10143     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
10144                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10145 #else
10146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10147     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10148       setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
10149                                         Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10150 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10151 
10152     //=== VK_KHR_synchronization2 ===
10153 
10154     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10155     VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t                                  submitCount,
10156                                             const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
10157                                             VULKAN_HPP_NAMESPACE::Fence               fence,
10158                                             Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10159 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10161     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10162       submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
10163                   VULKAN_HPP_NAMESPACE::Fence fence                                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10164                   Dispatch const & d                                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10165 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10166 
10167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10168     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
10169                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
10170                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10172     template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
10173               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10174     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
10175                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10176     template <
10177       typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
10178       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10179       typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>
10180     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
10181       getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10182 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10183 
10184     //=== VK_NV_low_latency2 ===
10185 
10186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10187     void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
10188                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10189 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10191     void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,
10192                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10193 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10194 
operator VkQueue() const10195     operator VkQueue() const VULKAN_HPP_NOEXCEPT
10196     {
10197       return m_queue;
10198     }
10199 
operator bool() const10200     explicit operator bool() const VULKAN_HPP_NOEXCEPT
10201     {
10202       return m_queue != VK_NULL_HANDLE;
10203     }
10204 
operator !() const10205     bool operator!() const VULKAN_HPP_NOEXCEPT
10206     {
10207       return m_queue == VK_NULL_HANDLE;
10208     }
10209 
10210   private:
10211     VkQueue m_queue = {};
10212   };
10213 
10214   template <>
10215   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
10216   {
10217     using Type = VULKAN_HPP_NAMESPACE::Queue;
10218   };
10219 
10220   template <>
10221   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
10222   {
10223     using Type = VULKAN_HPP_NAMESPACE::Queue;
10224   };
10225 
10226 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
10227   template <>
10228   struct CppType<VkQueue, VK_NULL_HANDLE>
10229   {
10230     using Type = VULKAN_HPP_NAMESPACE::Queue;
10231   };
10232 #endif
10233 
10234   template <>
10235   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
10236   {
10237     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10238   };
10239 
10240   class Device
10241   {
10242   public:
10243     using CType      = VkDevice;
10244     using NativeType = VkDevice;
10245 
10246     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
10247     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
10248       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
10249 
10250   public:
Device()10251     Device() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
10252     Device( Device const & rhs )             = default;
10253     Device & operator=( Device const & rhs ) = default;
10254 
10255 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
10256     Device( Device && rhs )             = default;
10257     Device & operator=( Device && rhs ) = default;
10258 #else
Device(Device && rhs)10259     Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) {}
10260 
operator =(Device && rhs)10261     Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT
10262     {
10263       m_device = VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} );
10264       return *this;
10265     }
10266 #endif
10267 
Device(std::nullptr_t)10268     VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
10269 
Device(VkDevice device)10270     Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
10271 
operator =(VkDevice device)10272     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
10273     {
10274       m_device = device;
10275       return *this;
10276     }
10277 
operator =(std::nullptr_t)10278     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10279     {
10280       m_device = {};
10281       return *this;
10282     }
10283 
10284 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
10285     auto operator<=>( Device const & ) const = default;
10286 #else
operator ==(Device const & rhs) const10287     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
10288     {
10289       return m_device == rhs.m_device;
10290     }
10291 
operator !=(Device const & rhs) const10292     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
10293     {
10294       return m_device != rhs.m_device;
10295     }
10296 
operator <(Device const & rhs) const10297     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
10298     {
10299       return m_device < rhs.m_device;
10300     }
10301 #endif
10302 
10303     //=== VK_VERSION_1_0 ===
10304 
10305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10306     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10309     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10310 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10311 
10312     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10313     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10314                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10315 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10317     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10318                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10319 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10320 
10321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10322     void getQueue( uint32_t                      queueFamilyIndex,
10323                    uint32_t                      queueIndex,
10324                    VULKAN_HPP_NAMESPACE::Queue * pQueue,
10325                    Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10327     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10328     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
10329       getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10330 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10331 
10332 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10334     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10335 #else
10336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10337     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10338 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10339 
10340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10341     VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
10342                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10343                                                 VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,
10344                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10346     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10347     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
10348       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,
10349                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10350                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10351 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10353     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
10354       allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo &                    allocateInfo,
10355                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10356                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10357 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10358 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10359 
10360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10361     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
10362                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10367                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10368                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10370 
10371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10372     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
10373                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10374                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10376     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10377     void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory                                  memory,
10378                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10379                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10381 
10382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10383     VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
10384                                            VULKAN_HPP_NAMESPACE::DeviceSize     offset,
10385                                            VULKAN_HPP_NAMESPACE::DeviceSize     size,
10386                                            VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
10387                                            void **                              ppData,
10388                                            Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10389 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10390     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10391     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
10392                                                                            VULKAN_HPP_NAMESPACE::DeviceSize           offset,
10393                                                                            VULKAN_HPP_NAMESPACE::DeviceSize           size,
10394                                                                            VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10395                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10396 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10397 
10398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10399     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10400 
10401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10402     VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
10403                                                          const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
10404                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10405 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10407     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10408       flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
10409                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10410 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10411 
10412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10413     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t                                        memoryRangeCount,
10414                                                               const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
10415                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10418     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10419       invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
10420                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10421 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10422 
10423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10424     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
10425                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
10426                               Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10428     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10429     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
10430       getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10432 
10433 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10434     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10435     VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
10436                                                   VULKAN_HPP_NAMESPACE::DeviceMemory memory,
10437                                                   VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
10438                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10439 #else
10440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10441     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10442       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
10443                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
10444                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
10445                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10446 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10447 
10448 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10450     VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
10451                                                  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
10452                                                  VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
10453                                                  Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10454 #else
10455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10456     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10457       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
10458                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
10459                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
10460                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10461 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10462 
10463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10464     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
10465                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
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     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
10470       getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10472 
10473     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10474     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
10475                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
10476                                      Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10479     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
10480       getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10481 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10482 
10483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10484     void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                           image,
10485                                            uint32_t *                                            pSparseMemoryRequirementCount,
10486                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
10487                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10489     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
10490               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10491     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
10492       getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10493     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
10494               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10495               typename std::enable_if<
10496                 std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
10497                 int>::type = 0>
10498     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
10499                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
10500                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
10501                                                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10502 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10503 
10504     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10505     VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
10506                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10507                                              VULKAN_HPP_NAMESPACE::Fence *                     pFence,
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     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
10512       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,
10513                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10514                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10515 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10517     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
10518       createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo &                       createInfo,
10519                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10520                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10521 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10522 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10523 
10524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10525     void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
10526                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10527                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10528 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10530     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10531                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10532                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10533 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10534 
10535     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10536     void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
10537                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10538                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10539 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10541     void destroy( VULKAN_HPP_NAMESPACE::Fence                                         fence,
10542                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10543                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10545 
10546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10547     VULKAN_HPP_NODISCARD Result resetFences( uint32_t                            fenceCount,
10548                                              const VULKAN_HPP_NAMESPACE::Fence * pFences,
10549                                              Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10552     typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
10553                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10555 
10556 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10558     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
10559                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10560 #else
10561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10562     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
10563                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10564 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10565 
10566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10567     VULKAN_HPP_NODISCARD Result waitForFences( uint32_t                            fenceCount,
10568                                                const VULKAN_HPP_NAMESPACE::Fence * pFences,
10569                                                VULKAN_HPP_NAMESPACE::Bool32        waitAll,
10570                                                uint64_t                            timeout,
10571                                                Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10572 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10573     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10574     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
10575                                                                      VULKAN_HPP_NAMESPACE::Bool32                                                waitAll,
10576                                                                      uint64_t                                                                    timeout,
10577                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10578 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10579 
10580     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10581     VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
10582                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10583                                                  VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
10584                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10585 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10586     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10587     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
10588       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,
10589                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10590                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10591 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10593     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
10594       createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo &                   createInfo,
10595                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10596                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10597 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10598 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10599 
10600     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10601     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
10602                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10603                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10604 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10606     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10607                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10608                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10609 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10610 
10611     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10612     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
10613                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                                     semaphore,
10618                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10619                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10620 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10621 
10622     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10623     VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
10624                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10625                                              VULKAN_HPP_NAMESPACE::Event *                     pEvent,
10626                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10629     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
10630       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,
10631                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10632                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10633 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10635     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
10636       createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo &                       createInfo,
10637                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10638                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10639 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10640 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10641 
10642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10643     void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
10644                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10645                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10647     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10648     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10649                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10650                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10651 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10652 
10653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10654     void destroy( VULKAN_HPP_NAMESPACE::Event                       event,
10655                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroy( VULKAN_HPP_NAMESPACE::Event                                         event,
10660                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10661                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10662 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10663 
10664 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10665     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10666     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
10667                                                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10668 #else
10669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10670     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
10671                                                                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10672 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10673 
10674 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10676     VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event,
10677                                           Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10678 #else
10679     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10680     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event,
10681                                                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10682 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10683 
10684 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10686     VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event,
10687                                             Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10688 #else
10689     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10690     typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10691 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10692 
10693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10694     VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
10695                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10696                                                  VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
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 typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
10701       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,
10702                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10703                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10704 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10706     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
10707       createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo &                   createInfo,
10708                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10709                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10710 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10711 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10712 
10713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10714     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
10715                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10716                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10719     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10720                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10721                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10722 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10723 
10724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10725     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
10726                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10727                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10728 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10730     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                                     queryPool,
10731                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10732                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10734 
10735     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10736     VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
10737                                                      uint32_t                               firstQuery,
10738                                                      uint32_t                               queryCount,
10739                                                      size_t                                 dataSize,
10740                                                      void *                                 pData,
10741                                                      VULKAN_HPP_NAMESPACE::DeviceSize       stride,
10742                                                      VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
10743                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10745     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10746     VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>
10747                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
10748                                               uint32_t                                     firstQuery,
10749                                               uint32_t                                     queryCount,
10750                                               size_t                                       dataSize,
10751                                               VULKAN_HPP_NAMESPACE::DeviceSize             stride,
10752                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10753                                               Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10754     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10755     VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
10756                                                                    uint32_t                                     firstQuery,
10757                                                                    uint32_t                                     queryCount,
10758                                                                    VULKAN_HPP_NAMESPACE::DeviceSize             stride,
10759                                                                    VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10760                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10761 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10762 
10763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10764     VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
10765                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10766                                               VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,
10767                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10770     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
10771       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,
10772                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10773                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10774 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10776     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
10777       createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo &                      createInfo,
10778                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10779                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10780 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10781 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10782 
10783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10784     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
10785                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10786                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10789     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer                                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10790                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10791                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10792 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10793 
10794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10795     void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
10796                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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 destroy( VULKAN_HPP_NAMESPACE::Buffer                                        buffer,
10801                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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     VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
10807                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
10808                                                   VULKAN_HPP_NAMESPACE::BufferView *                 pView,
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     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
10813       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,
10814                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10815                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10816 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10818     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
10819       createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo &                  createInfo,
10820                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10821                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10822 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10823 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10824 
10825     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10826     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
10827                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10828                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10829 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10831     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10832                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10833                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10835 
10836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10837     void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
10838                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10839                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10840 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10841     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10842     void destroy( VULKAN_HPP_NAMESPACE::BufferView                                    bufferView,
10843                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10844                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10845 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10846 
10847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10848     VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
10849                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10850                                              VULKAN_HPP_NAMESPACE::Image *                     pImage,
10851                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10854     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
10855       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,
10856                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10857                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10858 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10860     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
10861       createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo &                       createInfo,
10862                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10863                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10864 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10865 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10866 
10867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10868     void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
10869                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10870                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10871 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10873     void destroyImage( VULKAN_HPP_NAMESPACE::Image image                                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10874                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10875                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10876 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10877 
10878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10879     void destroy( VULKAN_HPP_NAMESPACE::Image                       image,
10880                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10881                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10882 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10884     void destroy( VULKAN_HPP_NAMESPACE::Image                                         image,
10885                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10886                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10887 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10888 
10889     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10890     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
10891                                     const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
10892                                     VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
10893                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10895     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10896     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout
10897                          getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
10898                                                     const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
10899                                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10900 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10901 
10902     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10903     VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
10904                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10905                                                  VULKAN_HPP_NAMESPACE::ImageView *                 pView,
10906                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10907 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10909     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
10910       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,
10911                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10912                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10913 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10915     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
10916       createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo &                   createInfo,
10917                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10918                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10919 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10920 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10921 
10922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10923     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
10924                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10925                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10926 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10928     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView                           VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10929                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10930                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10932 
10933     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10934     void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
10935                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10936                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10937 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10939     void destroy( VULKAN_HPP_NAMESPACE::ImageView                                     imageView,
10940                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10941                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10942 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10943 
10944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10945     VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
10946                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
10947                                                     VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
10948                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10949 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10950     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10951     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
10952       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,
10953                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10954                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10955 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10957     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
10958       createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo &                createInfo,
10959                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10960                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10961 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10962 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10963 
10964     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10965     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
10966                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10967                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10970     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule                     VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10971                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10972                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10974 
10975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10976     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
10977                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10978                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10981     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                                  shaderModule,
10982                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10983                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10985 
10986     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10987     VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
10988                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
10989                                                      VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
10990                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10993     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
10994       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,
10995                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10996                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10997 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10998     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10999     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
11000       createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo &               createInfo,
11001                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11002                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11003 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11004 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11005 
11006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11007     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
11008                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11009                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11010 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11012     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache                   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11013                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11014                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11016 
11017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11018     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
11019                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11020                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11022     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11023     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11024                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11025                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11027 
11028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11029     VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11030                                                       size_t *                            pDataSize,
11031                                                       void *                              pData,
11032                                                       Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11033 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11034     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11035     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
11036       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11037     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
11038               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11039               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
11040     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
11041       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11042                             Uint8_tAllocator &                  uint8_tAllocator,
11043                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11045 
11046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11047     VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
11048                                                      uint32_t                                    srcCacheCount,
11049                                                      const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
11050                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11052     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11053     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11054       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                                                 dstCache,
11055                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
11056                            Dispatch const & d                                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11057 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11058 
11059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11060     VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
11061                                                          uint32_t                                                 createInfoCount,
11062                                                          const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
11063                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
11064                                                          VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
11065                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11066 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11067     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11068     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11069                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
11070                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
11071                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11072                                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11073     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11074               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11075               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
11076     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11077                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
11078                                                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
11079                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,
11080                                                   PipelineAllocator &                                                                              pipelineAllocator,
11081                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11082     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11083     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
11084                          createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11085                                                  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,
11086                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11087                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11088 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11089     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11090               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11091     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11092                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
11093                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
11094                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11095                                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11096     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11097               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11098               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
11099                                       int>::type = 0>
11100     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11101                          createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                              pipelineCache,
11102                                                         VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
11103                                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                        allocator,
11104                                                         PipelineAllocator &                                                                              pipelineAllocator,
11105                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11107     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
11108                          createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11109                                                        const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo &            createInfo,
11110                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11111                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11112 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11113 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11114 
11115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11116     VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
11117                                                         uint32_t                                                createInfoCount,
11118                                                         const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
11119                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
11120                                                         VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,
11121                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11122 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11123     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11124     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11125                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
11126                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
11127                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11128                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11129     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11130               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11131               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
11132     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11133                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
11134                                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
11135                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,
11136                                                  PipelineAllocator &                                                                             pipelineAllocator,
11137                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11139     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
11140                          createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11141                                                 const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,
11142                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11143                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11144 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11145     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11146               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11147     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11148                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
11149                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
11150                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11151                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11152     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11153               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11154               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
11155                                       int>::type = 0>
11156     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
11157                          createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                             pipelineCache,
11158                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
11159                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                       allocator,
11160                                                        PipelineAllocator &                                                                             pipelineAllocator,
11161                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11163     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
11164                          createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
11165                                                       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo &             createInfo,
11166                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11167                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11168 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11169 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11170 
11171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11172     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
11173                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11174                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11176     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11177     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11178                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11179                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11181 
11182     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11183     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
11184                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                                      pipeline,
11189                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11190                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11191 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11192 
11193     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11194     VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
11195                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
11196                                                       VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
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 typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
11201       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,
11202                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11203                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11204 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11206     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
11207       createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo &              createInfo,
11208                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11209                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11210 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11211 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11212 
11213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11214     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
11215                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11216                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11219     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11220                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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 destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
11226                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11227                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11228 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11229     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11230     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout                                pipelineLayout,
11231                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11232                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11233 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11234 
11235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11236     VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
11237                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11238                                                VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
11239                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11242     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
11243       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,
11244                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11245                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11246 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11247     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11248     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
11249       createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo &                     createInfo,
11250                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11251                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11252 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11253 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11254 
11255     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11256     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
11257                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11258                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11261     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler                               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11262                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11263                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11265 
11266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11267     void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
11268                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11269                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11272     void destroy( VULKAN_HPP_NAMESPACE::Sampler                                       sampler,
11273                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11274                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11275 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11276 
11277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11278     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
11279                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
11280                                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
11281                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11282 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11284     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
11285       createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,
11286                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11287                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11288 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11289     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11290     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
11291       createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo &         createInfo,
11292                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11293                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11294 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11295 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11296 
11297     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11298     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
11299                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11300                                      Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11303     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11304                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11305                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11307 
11308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11309     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
11310                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11311                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11312 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11314     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout                           descriptorSetLayout,
11315                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11316                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11317 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11318 
11319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11320     VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
11321                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
11322                                                       VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,
11323                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11325     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11326     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
11327       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,
11328                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11329                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11330 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11332     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
11333       createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo &              createInfo,
11334                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11335                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11336 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11337 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11338 
11339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11340     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
11341                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11342                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11345     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool                 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11346                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11347                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11348 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11349 
11350     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11351     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
11352                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11353                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11356     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool                                descriptorPool,
11357                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11358                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11359 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11360 
11361 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11362     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11363     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
11364                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
11365                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11366 #else
11367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11368     void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
11369                               VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11370                               Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11371 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11372 
11373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11374     VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
11375                                                         VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
11376                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11378     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11379     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
11380       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
11381                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11382     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,
11383               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11384               typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>
11385     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
11386       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
11387                               DescriptorSetAllocator &                                descriptorSetAllocator,
11388                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11389 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11390     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11391               typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
11392     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
11393       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
11394                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11395     template <
11396       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11397       typename DescriptorSetAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
11398       typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value,
11399                               int>::type = 0>
11400     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
11401       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
11402                                     DescriptorSetAllocator &                                descriptorSetAllocator,
11403                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11404 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11405 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11406 
11407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11408     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
11409                                uint32_t                                    descriptorSetCount,
11410                                const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
11411                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11413     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11414     void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,
11415                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
11416                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11417 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11418 
11419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11420     Result( free )( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
11421                     uint32_t                                    descriptorSetCount,
11422                     const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
11423                     Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11424 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11425     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11426     void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool                                                descriptorPool,
11427                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
11428                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11429 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11430 
11431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11432     void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
11433                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
11434                                uint32_t                                         descriptorCopyCount,
11435                                const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
11436                                Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11439     void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
11440                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
11441                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11442 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11443 
11444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11445     VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
11446                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11447                                                    VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
11448                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11450     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11451     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
11452       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,
11453                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11454                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11455 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11457     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
11458       createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo &                 createInfo,
11459                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11460                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11461 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11462 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11463 
11464     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11465     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
11466                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11467                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11469     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11470     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11471                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11472                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11473 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11474 
11475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11476     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
11477                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11478                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11480     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11481     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                                   framebuffer,
11482                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11483                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11485 
11486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11487     VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
11488                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
11489                                                   VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
11490                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11492     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11493     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
11494       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,
11495                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11496                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11497 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11498     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11499     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
11500       createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo &                  createInfo,
11501                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11502                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11503 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11504 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11505 
11506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11507     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
11508                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11509                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11512     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass                         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11513                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11514                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11515 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11516 
11517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11518     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
11519                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11520                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11523     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                                    renderPass,
11524                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11525                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11526 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11527 
11528     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11529     void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
11530                                    VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
11531                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11534     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
11535                          getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
11536                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11537 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11538 
11539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11540     VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
11541                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11542                                                    VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
11543                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11546     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
11547       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,
11548                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11549                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11550 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11552     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
11553       createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo &                 createInfo,
11554                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11555                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11556 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11557 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11558 
11559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11560     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
11561                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11562                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11565     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool                       VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11566                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11567                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11568 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11569 
11570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11571     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
11572                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11573                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11576     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                                   commandPool,
11577                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11578                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11580 
11581 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11583     VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
11584                                                   VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
11585                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11586 #else
11587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11588     typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
11589                                                            VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11590                                                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11591 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11592 
11593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11594     VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
11595                                                         VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
11596                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11597 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11598     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11599     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
11600       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
11601                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11602     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,
11603               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11604               typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>
11605     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
11606       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
11607                               CommandBufferAllocator &                                commandBufferAllocator,
11608                               Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11609 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11610     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11611               typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
11612     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
11613       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
11614                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11615     template <
11616       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11617       typename CommandBufferAllocator    = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
11618       typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value,
11619                               int>::type = 0>
11620     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
11621       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
11622                                     CommandBufferAllocator &                                commandBufferAllocator,
11623                                     Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11624 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11625 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11626 
11627     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11628     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
11629                              uint32_t                                    commandBufferCount,
11630                              const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
11631                              Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11632 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11634     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,
11635                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
11636                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11638 
11639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11640     void( free )( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
11641                   uint32_t                                    commandBufferCount,
11642                   const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
11643                   Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11646     void( free )( VULKAN_HPP_NAMESPACE::CommandPool                                                   commandPool,
11647                   VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
11648                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11649 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11650 
11651     //=== VK_VERSION_1_1 ===
11652 
11653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11654     VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t                                           bindInfoCount,
11655                                                    const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
11656                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11659     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11660       bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
11661                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11662 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11663 
11664     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11665     VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t                                          bindInfoCount,
11666                                                   const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
11667                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11670     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11671       bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
11672                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11673 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11674 
11675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11676     void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
11677                                      uint32_t                                       localDeviceIndex,
11678                                      uint32_t                                       remoteDeviceIndex,
11679                                      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
11680                                      Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11683     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
11684                          getGroupPeerMemoryFeatures( uint32_t           heapIndex,
11685                                                      uint32_t           localDeviceIndex,
11686                                                      uint32_t           remoteDeviceIndex,
11687                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11688 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11689 
11690     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11691     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
11692                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
11693                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11696     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11697                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
11698                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11699     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11700     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11701                          getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
11702                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11704 
11705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11706     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
11707                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
11708                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11709 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11711     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11712                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
11713                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11714     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11715     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11716                          getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
11717                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11719 
11720     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11721     void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
11722                                             uint32_t *                                                       pSparseMemoryRequirementCount,
11723                                             VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
11724                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11725 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11726     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11727               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11728     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11729                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
11730                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11731     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11732               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11733               typename std::enable_if<
11734                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
11735                 int>::type = 0>
11736     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11737                          getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
11738                                                             SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
11739                                                             Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11740 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11741 
11742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11743     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
11744                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
11745                           Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11746 
11747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11748     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
11749                     VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
11750                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11753     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,
11754                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11755 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11756 
11757     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11758     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
11759                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
11760                                                               VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
11761                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11764     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
11765       createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
11766                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11767                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11768 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11770     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
11771       createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
11772                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11773                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11774 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11775 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11776 
11777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11778     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
11779                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11780                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11781 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11782     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11783     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11784                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11785                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11786 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11787 
11788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11789     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
11790                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11791                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11792 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11794     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion                        ycbcrConversion,
11795                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11796                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11797 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11798 
11799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11800     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
11801                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
11802                                                                 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
11803                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11804 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11806     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
11807       createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
11808                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11809                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11810 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11812     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
11813       createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
11814                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11815                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11816 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11817 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11818 
11819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11820     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
11821                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11822                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11825     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11826                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11827                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11829 
11830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11831     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
11832                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11833                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11835     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11836     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate                      descriptorUpdateTemplate,
11837                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11838                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11839 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11840 
11841     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11842     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11843                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11844                                           const void *                                   pData,
11845                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11846 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11847     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11848     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
11849                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11850                                           DataType const &                               data,
11851                                           Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11853 
11854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11855     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
11856                                         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
11857                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11860     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
11861                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
11862                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11863     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11864     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11865                          getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
11866                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11867 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11868 
11869     //=== VK_VERSION_1_2 ===
11870 
11871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11872     VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
11873                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
11874                                                    VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
11875                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11878     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
11879       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
11880                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11881                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11882 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11884     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
11885       createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
11886                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11887                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11888 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11889 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11890 
11891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11892     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
11893                          uint32_t                        firstQuery,
11894                          uint32_t                        queryCount,
11895                          Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11896 
11897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11898     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11899                                                           uint64_t *                      pValue,
11900                                                           Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11902     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11903     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11904                                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11905 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11906 
11907     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11908     VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
11909                                                 uint64_t                                        timeout,
11910                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11911 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11913     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
11914                                                                       uint64_t                                        timeout,
11915                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11917 
11918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11919     VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
11920                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11921 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11923     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11924       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11925 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11926 
11927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11928     DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11929                                     Dispatch const & d                                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11930 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11931     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11932     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11933                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11934 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11935 
11936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11937     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11938                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11939 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11940     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11941     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11942                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11944 
11945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11946     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
11947                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11948 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11949     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11950     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
11951                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11952 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11953 
11954     //=== VK_VERSION_1_3 ===
11955 
11956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11957     VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
11958                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
11959                                                        VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,
11960                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11961 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11962     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11963     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type
11964       createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
11965                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11966                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11967 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11969     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type
11970       createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
11971                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11972                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11973 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11974 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11975 
11976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11977     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
11978                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11979                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11980 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11982     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11983                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11984                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11985 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11986 
11987     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11988     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
11989                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11990                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11993     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot                               privateDataSlot,
11994                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11995                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11996 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11997 
11998 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12000     VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12001                                                 uint64_t                              objectHandle,
12002                                                 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12003                                                 uint64_t                              data,
12004                                                 Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12005 #else
12006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12007     typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12008                                                          uint64_t                              objectHandle,
12009                                                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12010                                                          uint64_t                              data,
12011                                                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12012 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12013 
12014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12015     void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12016                          uint64_t                              objectHandle,
12017                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12018                          uint64_t *                            pData,
12019                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12022     VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
12023                                                   uint64_t                              objectHandle,
12024                                                   VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12025                                                   Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12027 
12028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12029     void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
12030                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,
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 VULKAN_HPP_NAMESPACE::MemoryRequirements2
12035                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
12036                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12037     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12038     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12039                          getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
12040                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12042 
12043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12044     void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
12045                                      VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
12046                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12047 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12048     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12049     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
12050                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
12051                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12052     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12053     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12054                          getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
12055                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12056 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12057 
12058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12059     void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
12060                                            uint32_t *                                                  pSparseMemoryRequirementCount,
12061                                            VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,
12062                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12064     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
12065               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12066     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12067                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
12068                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12069     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
12070               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12071               typename std::enable_if<
12072                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
12073                 int>::type = 0>
12074     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12075                          getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
12076                                                            SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
12077                                                            Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12079 
12080     //=== VK_VERSION_1_4 ===
12081 
12082     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12083     VULKAN_HPP_NODISCARD Result mapMemory2( const VULKAN_HPP_NAMESPACE::MemoryMapInfo * pMemoryMapInfo,
12084                                             void **                                     ppData,
12085                                             Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12087     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12088     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo,
12089                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12091 
12092     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12093     VULKAN_HPP_NODISCARD Result unmapMemory2( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo * pMemoryUnmapInfo,
12094                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12095 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12096     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12097     typename ResultValueType<void>::type unmapMemory2( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo,
12098                                                        Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12099 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12100 
12101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12102     void getRenderingAreaGranularity( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo * pRenderingAreaInfo,
12103                                       VULKAN_HPP_NAMESPACE::Extent2D *                pGranularity,
12104                                       Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12107     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
12108                          getRenderingAreaGranularity( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo,
12109                                                       Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12110 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12111 
12112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12113     void getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo * pInfo,
12114                                     VULKAN_HPP_NAMESPACE::SubresourceLayout2 *               pLayout,
12115                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12116 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12117     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12118     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2
12119                          getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info,
12120                                                     Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12121     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12122     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12123                          getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info,
12124                                                     Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12126 
12127     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12128     void getImageSubresourceLayout2( VULKAN_HPP_NAMESPACE::Image                     image,
12129                                      const VULKAN_HPP_NAMESPACE::ImageSubresource2 * pSubresource,
12130                                      VULKAN_HPP_NAMESPACE::SubresourceLayout2 *      pLayout,
12131                                      Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12132 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12133     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12134     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2
12135                          getImageSubresourceLayout2( VULKAN_HPP_NAMESPACE::Image                     image,
12136                                                      const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource,
12137                                                      Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12138     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12139     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12140                          getImageSubresourceLayout2( VULKAN_HPP_NAMESPACE::Image                     image,
12141                                                      const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource,
12142                                                      Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12143 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12144 
12145     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12146     VULKAN_HPP_NODISCARD Result copyMemoryToImage( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
12147                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12150     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12151       copyMemoryToImage( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo,
12152                          Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12153 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12154 
12155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12156     VULKAN_HPP_NODISCARD Result copyImageToMemory( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
12157                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12158 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12159     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12160     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12161       copyImageToMemory( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo,
12162                          Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12164 
12165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12166     VULKAN_HPP_NODISCARD Result copyImageToImage( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo * pCopyImageToImageInfo,
12167                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12170     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12171       copyImageToImage( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo,
12172                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12174 
12175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12176     VULKAN_HPP_NODISCARD Result transitionImageLayout( uint32_t                                                    transitionCount,
12177                                                        const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo * pTransitions,
12178                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12179 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12181     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12182       transitionImageLayout( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions,
12183                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12185 
12186     //=== VK_KHR_swapchain ===
12187 
12188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12189     VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
12190                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
12191                                                     VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
12192                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12195     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
12196       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
12197                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12198                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12199 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12201     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
12202       createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
12203                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12204                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12205 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12206 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12207 
12208     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12209     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
12210                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12211                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12214     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain                        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12215                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12216                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12218 
12219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12220     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
12221                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12222                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12223 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12225     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                                  swapchain,
12226                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12227                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12229 
12230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12231     VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12232                                                        uint32_t *                         pSwapchainImageCount,
12233                                                        VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
12234                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12236     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12237     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type
12238       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12239     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,
12240               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12241               typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>
12242     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR(
12243       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12245 
12246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12247     VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12248                                                      uint64_t                           timeout,
12249                                                      VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
12250                                                      VULKAN_HPP_NAMESPACE::Fence        fence,
12251                                                      uint32_t *                         pImageIndex,
12252                                                      Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12253 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12254     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12255     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
12256                                                                     uint64_t                                  timeout,
12257                                                                     VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12258                                                                     VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12259                                                                     Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12260 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12261 
12262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12263     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
12264                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12267     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
12268       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12269 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12270 
12271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12272     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
12273                                                                 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
12274                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12275 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12277     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
12278       getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12280 
12281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12282     VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
12283                                                       uint32_t *                                            pImageIndex,
12284                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12286     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12287     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,
12288                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12289 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12290 
12291     //=== VK_KHR_display_swapchain ===
12292 
12293     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12294     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t                                             swapchainCount,
12295                                                            const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
12296                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
12297                                                            VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
12298                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12300     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12301     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
12302       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
12303                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12304                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12305     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,
12306               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12307               typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>
12308     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
12309       createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
12310                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
12311                                  SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,
12312                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12314     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
12315       createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
12316                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12317                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12318 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12319     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12320               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
12321     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
12322       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
12323                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12324                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12325     template <
12326       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12327       typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
12328       typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value,
12329                               int>::type = 0>
12330     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
12331       createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
12332                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                    allocator,
12333                                        SwapchainKHRAllocator &                                                                      swapchainKHRAllocator,
12334                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12336     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
12337       createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR &                createInfo,
12338                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12339                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12340 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12341 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12342 
12343     //=== VK_EXT_debug_marker ===
12344 
12345     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12346     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
12347                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12348 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12350     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12351       debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,
12352                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12353 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12354 
12355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12356     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
12357                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12358 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12360     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12361       debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,
12362                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12363 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12364 
12365     //=== VK_KHR_video_queue ===
12366 
12367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12368     VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
12369                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
12370                                                        VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
12371                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12374     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
12375       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,
12376                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12377                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12378 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12380     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
12381       createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR &             createInfo,
12382                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12383                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12384 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12385 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12386 
12387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12388     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
12389                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12390                                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12393     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession                  VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12394                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12395                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12396 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12397 
12398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12399     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
12400                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR                               videoSession,
12405                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                     videoSession,
12411                                                                       uint32_t *                                                pMemoryRequirementsCount,
12412                                                                       VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
12413                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12415     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
12416               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12417     VULKAN_HPP_NODISCARD
12418       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
12419       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
12420                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12421     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
12422               typename Dispatch                                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12423               typename std::enable_if<
12424                 std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value,
12425                 int>::type = 0>
12426     VULKAN_HPP_NODISCARD
12427       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type
12428       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR        videoSession,
12429                                             VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
12430                                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12432 
12433     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12434     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                       videoSession,
12435                                                            uint32_t                                                    bindSessionMemoryInfoCount,
12436                                                            const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
12437                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12438 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12440     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12441       bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR                                                               videoSession,
12442                                  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,
12443                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12444 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12445 
12446     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12447     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
12448                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
12449                                                                  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
12450                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12453     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
12454       createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,
12455                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12456                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12457 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12459     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
12460       createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR &   createInfo,
12461                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12462                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12463 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12464 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12465 
12466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12467     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
12468                                                                  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
12469                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12471     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12472     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12473       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
12474                                        const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
12475                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12476 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12477 
12478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12479     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
12480                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12481                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12482 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12484     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12485                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12486                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12487 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12488 
12489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12490     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
12491                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12492                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12494     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12495     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                     videoSessionParameters,
12496                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12497                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12498 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12499 
12500     //=== VK_NVX_binary_import ===
12501 
12502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12503     VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
12504                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
12505                                                    VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
12506                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12509     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
12510       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,
12511                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12512                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12513 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12515     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
12516       createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX &                 createInfo,
12517                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12518                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12519 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12520 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12521 
12522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12523     VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
12524                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
12525                                                      VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
12526                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12527 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12528     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12529     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
12530       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,
12531                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12532                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12533 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12535     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
12536       createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX &               createInfo,
12537                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12538                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12539 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12540 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12541 
12542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12543     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
12544                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12545                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12546 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12548     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,
12549                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12550                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12551 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12552 
12553     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12554     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
12555                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12556                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12557 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12559     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                                   module,
12560                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12561                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12563 
12564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12565     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
12566                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12567                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12568 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12569     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12570     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,
12571                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12572                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12574 
12575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12576     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
12577                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12578                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12580     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12581     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX                                 function,
12582                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12583                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12584 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12585 
12586     //=== VK_NVX_image_view_handle ===
12587 
12588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12589     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
12590                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12591 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12593     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
12594                                     Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12595 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12596 
12597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12598     VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
12599                                                         VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
12600                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12603     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
12604       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12605 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12606 
12607     //=== VK_AMD_shader_info ===
12608 
12609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12610     VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
12611                                                   VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
12612                                                   VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
12613                                                   size_t *                                  pInfoSize,
12614                                                   void *                                    pInfo,
12615                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12616 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12617     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12618     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12619       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
12620                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
12621                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
12622                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12623     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
12624               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12625               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
12626     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
12627       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
12628                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
12629                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
12630                         Uint8_tAllocator &                        uint8_tAllocator,
12631                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12632 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12633 
12634 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12635     //=== VK_NV_external_memory_win32 ===
12636 
12637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12638     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
12639                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
12640                                                         HANDLE *                                              pHandle,
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     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
12645                                                                                         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
12646                                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12647 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12648 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12649 
12650     //=== VK_KHR_device_group ===
12651 
12652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12653     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
12654                                         uint32_t                                       localDeviceIndex,
12655                                         uint32_t                                       remoteDeviceIndex,
12656                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
12657                                         Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12658 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12659     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12660     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
12661                          getGroupPeerMemoryFeaturesKHR( uint32_t           heapIndex,
12662                                                         uint32_t           localDeviceIndex,
12663                                                         uint32_t           remoteDeviceIndex,
12664                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12665 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12666 
12667     //=== VK_KHR_maintenance1 ===
12668 
12669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12670     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
12671                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
12672                              Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12673 
12674 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12675     //=== VK_KHR_external_memory_win32 ===
12676 
12677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12678     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
12679                                                          HANDLE *                                                  pHandle,
12680                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12681 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12683     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
12684       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
12685                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12686 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12687 
12688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12689     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
12690                                                                    HANDLE                                                 handle,
12691                                                                    VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
12692                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12693 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12695     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR(
12696       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12697 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12698 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12699 
12700     //=== VK_KHR_external_memory_fd ===
12701 
12702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12703     VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
12704                                                 int *                                            pFd,
12705                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12706 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12708     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,
12709                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12710 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12711 
12712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12713     VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
12714                                                           int                                                    fd,
12715                                                           VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
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     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR(
12720       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12721 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12722 
12723 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12724     //=== VK_KHR_external_semaphore_win32 ===
12725 
12726     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12727     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
12728                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12729 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12730     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12731     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12732       importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
12733                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12734 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12735 
12736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12737     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
12738                                                             HANDLE *                                                     pHandle,
12739                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12740 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12742     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
12743       getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
12744                                   Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12745 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12746 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12747 
12748     //=== VK_KHR_external_semaphore_fd ===
12749 
12750     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12751     VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
12752                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12753 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12755     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12756       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
12757                             Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12758 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12759 
12760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12761     VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
12762                                                    int *                                               pFd,
12763                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12764 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12765     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12766     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,
12767                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12768 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12769 
12770     //=== VK_KHR_descriptor_update_template ===
12771 
12772     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12773     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
12774                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
12775                                                                    VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
12776                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12777 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12778     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12779     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
12780       createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo &    createInfo,
12781                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12782                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12783 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12785     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
12786       createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
12787                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12788                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12789                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12790 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12791 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12792 
12793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12794     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
12795                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12796                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12797 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12798     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12799     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12800                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12801                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12802 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12803 
12804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12805     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
12806                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
12807                                              const void *                                   pData,
12808                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12809 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12810     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12811     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
12812                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
12813                                              DataType const &                               data,
12814                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12815 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12816 
12817     //=== VK_EXT_display_control ===
12818 
12819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12820     VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
12821                                                         const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
12822                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12825     typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
12826                                                                  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
12827                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12829 
12830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12831     VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
12832                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12833                                                   VULKAN_HPP_NAMESPACE::Fence *                     pFence,
12834                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12837     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
12838       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,
12839                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12840                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12841 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12842     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12843     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
12844       registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT &                    deviceEventInfo,
12845                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12846                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12847 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12848 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12849 
12850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12851     VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
12852                                                          const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
12853                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12854                                                          VULKAN_HPP_NAMESPACE::Fence *                     pFence,
12855                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12856 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12857     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12858     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
12859       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
12860                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,
12861                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12862                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12863 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12865     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
12866       registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
12867                                      const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT &                   displayEventInfo,
12868                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12869                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12870 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12871 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12872 
12873     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12874     VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
12875                                                         VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
12876                                                         uint64_t *                                      pCounterValue,
12877                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12880     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
12881                                                                                           VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
12882                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12883 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12884 
12885     //=== VK_GOOGLE_display_timing ===
12886 
12887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12888     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
12889                                                                VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
12890                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12892     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12893     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
12894       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12895 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12896 
12897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12898     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
12899                                                                  uint32_t *                                           pPresentationTimingCount,
12900                                                                  VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
12901                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12903     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
12904               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12905     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
12906       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12907     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
12908               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12909               typename std::enable_if<
12910                 std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
12911                 int>::type = 0>
12912     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
12913       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
12914                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
12915                                        Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12917 
12918     //=== VK_EXT_hdr_metadata ===
12919 
12920     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12921     void setHdrMetadataEXT( uint32_t                                     swapchainCount,
12922                             const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
12923                             const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
12924                             Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12925 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12927     void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
12928                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
12929                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
12930 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12931 
12932     //=== VK_KHR_create_renderpass2 ===
12933 
12934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12935     VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
12936                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
12937                                                       VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
12938                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12939 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12940     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12941     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
12942       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
12943                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12944                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12945 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12946     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12947     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
12948       createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 &                 createInfo,
12949                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12950                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12951 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
12952 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12953 
12954     //=== VK_KHR_shared_presentable_image ===
12955 
12956 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12957     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12958     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12959                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12960 #else
12961     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12962     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12963                                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12964 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12965 
12966 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12967     //=== VK_KHR_external_fence_win32 ===
12968 
12969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12970     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
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_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12975       importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
12976                                  Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12977 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12978 
12979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12980     VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
12981                                                         HANDLE *                                                 pHandle,
12982                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12983 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12985     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type
12986       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
12987                               Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12988 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12989 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12990 
12991     //=== VK_KHR_external_fence_fd ===
12992 
12993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12994     VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
12995                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12998     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12999       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,
13000                         Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13001 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13002 
13003     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13004     VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
13005                                                int *                                           pFd,
13006                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13007 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13008     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13009     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,
13010                                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13011 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13012 
13013     //=== VK_KHR_performance_query ===
13014 
13015     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13016     VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
13017                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13019     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13020     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13021       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,
13022                                Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13023 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13024 
13025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13026     void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13027 
13028     //=== VK_EXT_debug_utils ===
13029 
13030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13031     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
13032                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13033 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13034     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13035     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13036       setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,
13037                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13038 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13039 
13040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13041     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
13042                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13043 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13045     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13046       setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,
13047                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13048 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13049 
13050 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
13051     //=== VK_ANDROID_external_memory_android_hardware_buffer ===
13052 
13053     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13054     VULKAN_HPP_NODISCARD Result
13055       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer *                                 buffer,
13056                                                  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
13057                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13058 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13060     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
13061       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13062     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13063     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
13064       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13065 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13066 
13067     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13068     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
13069                                                                        struct AHardwareBuffer **                                               pBuffer,
13070                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13071 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13073     VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type
13074       getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
13075                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13076 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13077 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
13078 
13079 #if defined( VK_ENABLE_BETA_EXTENSIONS )
13080     //=== VK_AMDX_shader_enqueue ===
13081 
13082     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13083     VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                pipelineCache,
13084                                                                    uint32_t                                                           createInfoCount,
13085                                                                    const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
13086                                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
13087                                                                    VULKAN_HPP_NAMESPACE::Pipeline *                                   pPipelines,
13088                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13089 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13090     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13091     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
13092                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
13093                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
13094                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13095                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13096     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
13097               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13098               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
13099     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
13100                          createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
13101                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
13102                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,
13103                                                             PipelineAllocator & pipelineAllocator,
13104                                                             Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13106     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
13107                          createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
13108                                                            const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,
13109                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13110                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13111 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13112     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13113               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
13114     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
13115                          createExecutionGraphPipelinesAMDXUnique(
13116                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
13117                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
13118                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13119                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13120     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13121               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
13122               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
13123                                       int>::type = 0>
13124     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
13125                          createExecutionGraphPipelinesAMDXUnique(
13126                            VULKAN_HPP_NAMESPACE::PipelineCache                                                                        pipelineCache,
13127                            VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
13128                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                                  allocator,
13129                            PipelineAllocator &                                                                                        pipelineAllocator,
13130                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13131     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13132     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createExecutionGraphPipelineAMDXUnique(
13133       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
13134       const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX &  createInfo,
13135       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13136       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13137 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
13138 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13139 
13140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13141     VULKAN_HPP_NODISCARD Result
13142       getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                executionGraph,
13143                                                 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
13144                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13145 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13147     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX>::type
13148       getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
13149                                                 Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13150 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13151 
13152     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13153     VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,
13154                                                                         const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
13155                                                                         uint32_t *                                                          pNodeIndex,
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     VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type
13160       getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline                                      executionGraph,
13161                                               const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo,
13162                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13163 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13164 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
13165 
13166     //=== VK_KHR_get_memory_requirements2 ===
13167 
13168     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13169     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
13170                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
13171                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13173     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13174     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13175                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
13176                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13177     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13178     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13179                          getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
13180                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13181 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13182 
13183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13184     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
13185                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
13186                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13187 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13189     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13190                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
13191                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13192     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13193     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13194                          getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
13195                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13196 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13197 
13198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13199     void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
13200                                                uint32_t *                                                       pSparseMemoryRequirementCount,
13201                                                VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
13202                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13204     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
13205               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13206     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13207                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
13208                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13209     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
13210               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13211               typename std::enable_if<
13212                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
13213                 int>::type = 0>
13214     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13215                          getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
13216                                                                SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
13217                                                                Dispatch const & d                                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13218 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13219 
13220     //=== VK_KHR_acceleration_structure ===
13221 
13222     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13223     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
13224                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
13225                                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
13226                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13227 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13228     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13229     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
13230       createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,
13231                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13232                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13233 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13235     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
13236       createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR &    createInfo,
13237                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13238                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13239 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13240 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13241 
13242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13243     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
13244                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13245                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13247     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13248     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13249                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13250                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13251 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13252 
13253     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13254     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
13255                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13256                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13259     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR                      accelerationStructure,
13260                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13261                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13262 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13263 
13264     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13265     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
13266                                                                 uint32_t                                                                     infoCount,
13267                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
13268                                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
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 VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(
13273       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                                           deferredOperation,
13274       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
13275       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
13276       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13277 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13278 
13279     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13280     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
13281                                                               const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
13282                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13284     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13285     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13286                                                                                     const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
13287                                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13288 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13289 
13290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13291     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
13292                                                                       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
13293                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13294 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13295     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13296     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
13297                          copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
13298                                                                const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
13299                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13300 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13301 
13302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13303     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
13304                                                                       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
13305                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13307     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13308     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
13309                          copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
13310                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
13311                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13313 
13314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13315     VULKAN_HPP_NODISCARD Result
13316       writeAccelerationStructuresPropertiesKHR( uint32_t                                               accelerationStructureCount,
13317                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
13318                                                 VULKAN_HPP_NAMESPACE::QueryType                        queryType,
13319                                                 size_t                                                 dataSize,
13320                                                 void *                                                 pData,
13321                                                 size_t                                                 stride,
13322                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13323 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13324     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13325     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR(
13326       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
13327       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
13328       size_t                                                                                         dataSize,
13329       size_t                                                                                         stride,
13330       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13331     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13332     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR(
13333       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
13334       VULKAN_HPP_NAMESPACE::QueryType                                                                queryType,
13335       size_t                                                                                         stride,
13336       Dispatch const & d                                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13337 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13338 
13339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13340     DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
13341                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13344     VULKAN_HPP_NAMESPACE::DeviceAddress
13345       getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,
13346                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13348 
13349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13350     void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
13351                                                    VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
13352                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13353 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13354     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13355     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
13356                          getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,
13357                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13359 
13360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13361     void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
13362                                                 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
13363                                                 const uint32_t *                                                        pMaxPrimitiveCounts,
13364                                                 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
13365                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13368     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(
13369       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                     buildType,
13370       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR &     buildInfo,
13371       VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13372       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
13373 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13374 
13375     //=== VK_KHR_ray_tracing_pipeline ===
13376 
13377     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13378     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
13379                                                               VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
13380                                                               uint32_t                                                      createInfoCount,
13381                                                               const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
13382                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,
13383                                                               VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,
13384                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13385 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13386     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13387     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
13388                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
13389                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
13390                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
13391                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13392                                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13393     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
13394               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13395               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
13396     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
13397                          createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                            deferredOperation,
13398                                                        VULKAN_HPP_NAMESPACE::PipelineCache                                                                   pipelineCache,
13399                                                        VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
13400                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,
13401                                                        PipelineAllocator &                                                                                   pipelineAllocator,
13402                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13404     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
13405                          createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,
13406                                                       VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
13407                                                       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,
13408                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13409                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13410 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13411     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13412               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
13413     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
13414                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13415                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
13416                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
13417                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13418                                                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13419     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13420               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
13421               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
13422                                       int>::type = 0>
13423     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
13424                          createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13425                                                              VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
13426                                                              VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
13427                                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                             allocator,
13428                                                              PipelineAllocator & pipelineAllocator,
13429                                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13431     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
13432                          createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          deferredOperation,
13433                                                             VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
13434                                                             const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR &       createInfo,
13435                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13436                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13437 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13438 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13439 
13440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13441     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13442                                                                     uint32_t                       firstGroup,
13443                                                                     uint32_t                       groupCount,
13444                                                                     size_t                         dataSize,
13445                                                                     void *                         pData,
13446                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13448     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13449     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
13450       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13451                                           uint32_t                       firstGroup,
13452                                           uint32_t                       groupCount,
13453                                           size_t                         dataSize,
13454                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13455     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13456     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR(
13457       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13458 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13459 
13460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13461     VULKAN_HPP_NODISCARD Result
13462       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13463                                                        uint32_t                       firstGroup,
13464                                                        uint32_t                       groupCount,
13465                                                        size_t                         dataSize,
13466                                                        void *                         pData,
13467                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13469     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13470     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
13471       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13472                                                        uint32_t                       firstGroup,
13473                                                        uint32_t                       groupCount,
13474                                                        size_t                         dataSize,
13475                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13476     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13477     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR(
13478       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13479 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13480 
13481     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13482     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
13483                                                      uint32_t                                   group,
13484                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
13485                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13486 
13487     //=== VK_KHR_sampler_ycbcr_conversion ===
13488 
13489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13490     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
13491                                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
13492                                                                  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
13493                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13495     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13496     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
13497       createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
13498                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13499                                        Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13500 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13502     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
13503       createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo &      createInfo,
13504                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13505                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13506 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13507 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13508 
13509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13510     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
13511                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13512                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13515     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion        VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13516                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13517                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13519 
13520     //=== VK_KHR_bind_memory2 ===
13521 
13522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13523     VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
13524                                                       const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
13525                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13526 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13527     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13528     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13529       bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
13530                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13532 
13533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13534     VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t                                          bindInfoCount,
13535                                                      const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
13536                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13537 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13538     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13539     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13540       bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
13541                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13543 
13544     //=== VK_EXT_image_drm_format_modifier ===
13545 
13546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13547     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image                                 image,
13548                                                                         VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
13549                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13552     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
13553       getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13555 
13556     //=== VK_EXT_validation_cache ===
13557 
13558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13559     VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
13560                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
13561                                                           VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
13562                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13565     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
13566       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,
13567                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13568                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13569 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13571     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
13572       createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT &          createInfo,
13573                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13574                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13575 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13576 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13577 
13578     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13579     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
13580                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13581                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13584     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13585                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13586                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13587 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13588 
13589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13590     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
13591                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13592                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13593 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13595     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                            validationCache,
13596                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13597                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13598 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13599 
13600     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13601     VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
13602                                                           uint32_t                                         srcCacheCount,
13603                                                           const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
13604                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13606     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13607     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13608       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                                                 dstCache,
13609                                 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
13610                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13612 
13613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13614     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
13615                                                            size_t *                                 pDataSize,
13616                                                            void *                                   pData,
13617                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13618 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13619     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13620     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
13621       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13622     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
13623               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13624               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
13625     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
13626       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
13627                                  Uint8_tAllocator &                       uint8_tAllocator,
13628                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13629 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13630 
13631     //=== VK_NV_ray_tracing ===
13632 
13633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13634     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
13635                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
13636                                                                VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
13637                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13640     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
13641       createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,
13642                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13643                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13644 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13646     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
13647       createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV &     createInfo,
13648                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13649                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13650 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13651 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13652 
13653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13654     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
13655                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13656                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13659     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13660                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13661                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13662 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13663 
13664     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13665     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
13666                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13667                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13670     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV                       accelerationStructure,
13671                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13672                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13673 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13674 
13675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13676     void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
13677                                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
13678                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13681     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR
13682                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
13683                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13684     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13685     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13686                          getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
13687                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13688 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13689 
13690     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13691     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t                                                            bindInfoCount,
13692                                                                    const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
13693                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13696     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13697       bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
13698                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13700 
13701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13702     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
13703                                                              uint32_t                                                     createInfoCount,
13704                                                              const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
13705                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
13706                                                              VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
13707                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13708 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13709     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13710     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
13711                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
13712                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
13713                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13714                                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13715     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
13716               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13717               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
13718     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
13719                          createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
13720                                                       VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
13721                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,
13722                                                       PipelineAllocator &                                                                                  pipelineAllocator,
13723                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13725     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
13726                          createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
13727                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,
13728                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13729                                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13730 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13731     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13732               typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
13733     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
13734                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
13735                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
13736                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13737                                                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13738     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13739               typename PipelineAllocator         = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
13740               typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
13741                                       int>::type = 0>
13742     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>>
13743                          createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                                                  pipelineCache,
13744                                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
13745                                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                            allocator,
13746                                                             PipelineAllocator &                                                                                  pipelineAllocator,
13747                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13749     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>
13750                          createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                                 pipelineCache,
13751                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV &        createInfo,
13752                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13753                                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13754 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13755 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13756 
13757     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13758     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13759                                                                    uint32_t                       firstGroup,
13760                                                                    uint32_t                       groupCount,
13761                                                                    size_t                         dataSize,
13762                                                                    void *                         pData,
13763                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13764 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13765     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13766     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
13767       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13768                                          uint32_t                       firstGroup,
13769                                          uint32_t                       groupCount,
13770                                          size_t                         dataSize,
13771                                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13772     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13773     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV(
13774       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13775 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13776 
13777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13778     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
13779                                                                   size_t                                        dataSize,
13780                                                                   void *                                        pData,
13781                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13783     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13784     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(
13785       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13786     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13787     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
13788       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
13789                                         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13791 
13792 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13794     VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
13795                                                    uint32_t                       shader,
13796                                                    Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13797 #else
13798     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13799     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13800       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13801 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13802 
13803     //=== VK_KHR_maintenance3 ===
13804 
13805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13806     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
13807                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
13808                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13809 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13811     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
13812                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
13813                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13814     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13815     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13816                          getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
13817                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13818 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13819 
13820     //=== VK_EXT_external_memory_host ===
13821 
13822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13823     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
13824                                                                    const void *                                           pHostPointer,
13825                                                                    VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
13826                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13827 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13828     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13829     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
13830       getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
13831                                          const void *                                           pHostPointer,
13832                                          Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13833 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13834 
13835     //=== VK_EXT_calibrated_timestamps ===
13836 
13837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13838     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t                                                 timestampCount,
13839                                                             const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
13840                                                             uint64_t *                                               pTimestamps,
13841                                                             uint64_t *                                               pMaxDeviation,
13842                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13843 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13844     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13845     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
13846       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
13847                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13848     template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,
13849               typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13850               typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
13851     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
13852       getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
13853                                   Uint64_tAllocator &                                                                              uint64_tAllocator,
13854                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13856     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
13857       getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
13858                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13859 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13860 
13861     //=== VK_KHR_timeline_semaphore ===
13862 
13863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13864     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
13865                                                              uint64_t *                      pValue,
13866                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13867 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13869     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type
13870       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13871 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13872 
13873     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13874     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
13875                                                    uint64_t                                        timeout,
13876                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13877 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13879     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
13880                                                                          uint64_t                                        timeout,
13881                                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13882 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13883 
13884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13885     VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
13886                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13889     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13890       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13891 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13892 
13893     //=== VK_INTEL_performance_query ===
13894 
13895     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13896     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
13897                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13900     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13901       initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,
13902                                      Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13903 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13904 
13905     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13906     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13907 
13908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13909     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
13910                                                                       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
13911                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13912 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13913     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13914     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
13915       acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
13916                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13917 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13919     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
13920       acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
13921                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13922 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
13923 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13924 
13925 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13927     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
13928                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13929 #else
13930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13931     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13932       releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13933                                             Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13934 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13935 
13936 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13937     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13938     VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
13939                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13940 #else
13941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13942     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
13943                                                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13944 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13945 
13946     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13947     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
13948                                                               VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
13949                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13952     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
13953       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
13954                                     Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13955 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13956 
13957     //=== VK_AMD_display_native_hdr ===
13958 
13959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13960     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
13961                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
13962                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13963 
13964     //=== VK_EXT_buffer_device_address ===
13965 
13966     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13967     DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
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     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
13972                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13974 
13975     //=== VK_KHR_present_wait ===
13976 
13977 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13978     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13979     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13980                                                    uint64_t                           presentId,
13981                                                    uint64_t                           timeout,
13982                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13983 #else
13984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13985     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13986                                                                          uint64_t                           presentId,
13987                                                                          uint64_t                           timeout,
13988                                                                          Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13989 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13990 
13991 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13992     //=== VK_EXT_full_screen_exclusive ===
13993 
13994 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13995     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13996     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13997                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13998 #  else
13999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14000     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14001       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14002 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14003 
14004 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14005     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14006     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
14007                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14008 #  else
14009     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14010     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14011       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14012 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14013 
14014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14015     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
14016                                                                  VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
14017                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14018 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14019     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14020     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
14021       getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14022                                        Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14023 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14024 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
14025 
14026     //=== VK_KHR_buffer_device_address ===
14027 
14028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14029     DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
14030                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14031 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14032     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14033     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
14034                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14035 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14036 
14037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14038     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
14039                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14040 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14041     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14042     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
14043                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14045 
14046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14047     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
14048                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14049 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14051     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
14052                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14054 
14055     //=== VK_EXT_host_query_reset ===
14056 
14057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14058     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
14059                             uint32_t                        firstQuery,
14060                             uint32_t                        queryCount,
14061                             Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14062 
14063     //=== VK_KHR_deferred_host_operations ===
14064 
14065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14066     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14067                                                             VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
14068                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14069 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14070     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14071     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
14072       createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14073                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14074 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14075     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14076     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
14077       createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14078                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14079 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14080 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14081 
14082     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14083     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
14084                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14085                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14087     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14088     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation                VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14089                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14090                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14091 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14092 
14093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14094     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
14095                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14096                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14097 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14098     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14099     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                          operation,
14100                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14101                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14102 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14103 
14104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14105     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
14106                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14107 
14108 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14109     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14110     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
14111                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14112 #else
14113     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14114     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
14115                          getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
14116                                                         Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14117 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14118 
14119 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14121     VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
14122                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14123 #else
14124     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14125     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
14126                                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14127 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14128 
14129     //=== VK_KHR_pipeline_executable_properties ===
14130 
14131     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14132     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
14133                                                                     uint32_t *                                              pExecutableCount,
14134                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
14135                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14136 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14137     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
14138               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14139     VULKAN_HPP_NODISCARD
14140       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
14141       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
14142                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14143     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
14144               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14145               typename std::enable_if<
14146                 std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value,
14147                 int>::type = 0>
14148     VULKAN_HPP_NODISCARD
14149       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
14150       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
14151                                           PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,
14152                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14153 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14154 
14155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14156     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
14157                                                                     uint32_t *                                              pStatisticCount,
14158                                                                     VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
14159                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14160 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14161     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
14162               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14163     VULKAN_HPP_NODISCARD
14164       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
14165       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
14166                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14167     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
14168               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14169               typename std::enable_if<
14170                 std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value,
14171                 int>::type = 0>
14172     VULKAN_HPP_NODISCARD
14173       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
14174       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
14175                                           PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,
14176                                           Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14178 
14179     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14180     VULKAN_HPP_NODISCARD Result
14181       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
14182                                                        uint32_t *                                                          pInternalRepresentationCount,
14183                                                        VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
14184                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14185 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14186     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
14187               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14188     VULKAN_HPP_NODISCARD typename ResultValueType<
14189       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
14190       getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
14191                                                        Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14192     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
14193               typename Dispatch                                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14194               typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type,
14195                                                    VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,
14196                                       int>::type                            = 0>
14197     VULKAN_HPP_NODISCARD typename ResultValueType<
14198       std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
14199       getPipelineExecutableInternalRepresentationsKHR(
14200         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
14201         PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,
14202         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14203 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14204 
14205     //=== VK_EXT_host_image_copy ===
14206 
14207     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14208     VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo * pCopyMemoryToImageInfo,
14209                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14210 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14211     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14212     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14213       copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo,
14214                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14215 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14216 
14217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14218     VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo * pCopyImageToMemoryInfo,
14219                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14222     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14223       copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo,
14224                             Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14226 
14227     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14228     VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo * pCopyImageToImageInfo,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14233       copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo,
14234                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14236 
14237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14238     VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t                                                    transitionCount,
14239                                                           const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo * pTransitions,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14244       transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions,
14245                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14247 
14248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14249     void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                     image,
14250                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2 * pSubresource,
14251                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2 *      pLayout,
14252                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14253 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14254     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14255     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2
14256                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                     image,
14257                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource,
14258                                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14259     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14260     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14261                          getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image                     image,
14262                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource,
14263                                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14265 
14266     //=== VK_KHR_map_memory2 ===
14267 
14268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14269     VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfo * pMemoryMapInfo,
14270                                                void **                                     ppData,
14271                                                Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14273     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14274     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo,
14275                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14276 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14277 
14278     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14279     VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo * pMemoryUnmapInfo,
14280                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14282     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14283     typename ResultValueType<void>::type unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo,
14284                                                           Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14285 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14286 
14287     //=== VK_EXT_swapchain_maintenance1 ===
14288 
14289     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14290     VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo,
14291                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14293     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14294     typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo,
14295                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14296 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14297 
14298     //=== VK_NV_device_generated_commands ===
14299 
14300     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14301     void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
14302                                                    VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
14303                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14306     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
14307                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
14308                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14309     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14310     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14311                          getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
14312                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14313 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14314 
14315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14316     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
14317                                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
14318                                                                 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,
14319                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14322     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
14323       createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,
14324                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14325                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14326 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14327     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14328     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
14329       createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV &    createInfo,
14330                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14331                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14332 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14333 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14334 
14335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14336     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
14337                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14338                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14339 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14341     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14342                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14343                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14344 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14345 
14346     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14347     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
14348                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14349                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14350 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14351     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14352     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV                      indirectCommandsLayout,
14353                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14354                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14355 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14356 
14357     //=== VK_EXT_private_data ===
14358 
14359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14360     VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
14361                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
14362                                                           VULKAN_HPP_NAMESPACE::PrivateDataSlot *                 pPrivateDataSlot,
14363                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14365     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14366     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type
14367       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
14368                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14369                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14370 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14372     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type
14373       createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo &             createInfo,
14374                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14375                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14376 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14377 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14378 
14379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14380     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot             privateDataSlot,
14381                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14382                                     Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14383 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14385     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14386                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14387                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14388 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14389 
14390 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14392     VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
14393                                                    uint64_t                              objectHandle,
14394                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
14395                                                    uint64_t                              data,
14396                                                    Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14397 #else
14398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14399     typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
14400                                                             uint64_t                              objectHandle,
14401                                                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
14402                                                             uint64_t                              data,
14403                                                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14404 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14405 
14406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14407     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
14408                             uint64_t                              objectHandle,
14409                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
14410                             uint64_t *                            pData,
14411                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14413     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14414     VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
14415                                                      uint64_t                              objectHandle,
14416                                                      VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
14417                                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14418 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14419 
14420     //=== VK_KHR_video_encode_queue ===
14421 
14422     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14423     VULKAN_HPP_NODISCARD Result
14424       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
14425                                            VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR *  pFeedbackInfo,
14426                                            size_t *                                                             pDataSize,
14427                                            void *                                                               pData,
14428                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14430     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14431     VULKAN_HPP_NODISCARD
14432       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
14433       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
14434                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14435     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
14436               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14437               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
14438     VULKAN_HPP_NODISCARD
14439       typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
14440       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
14441                                            Uint8_tAllocator &                                                   uint8_tAllocator,
14442                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14443     template <typename X,
14444               typename Y,
14445               typename... Z,
14446               typename Uint8_tAllocator = std::allocator<uint8_t>,
14447               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14448     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
14449       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
14450                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14451     template <typename X,
14452               typename Y,
14453               typename... Z,
14454               typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
14455               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14456               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
14457     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
14458       getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
14459                                            Uint8_tAllocator &                                                   uint8_tAllocator,
14460                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14461 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14462 
14463 #if defined( VK_ENABLE_BETA_EXTENSIONS )
14464     //=== VK_NV_cuda_kernel_launch ===
14465 
14466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14467     VULKAN_HPP_NODISCARD Result createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo,
14468                                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
14469                                                     VULKAN_HPP_NAMESPACE::CudaModuleNV *                 pModule,
14470                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14471 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14473     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaModuleNV>::type
14474       createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,
14475                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14476                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14477 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14479     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>>::type
14480       createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV &                createInfo,
14481                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14482                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14483 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
14484 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14485 
14486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14487     VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
14488                                                       size_t *                           pCacheSize,
14489                                                       void *                             pCacheData,
14490                                                       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14491 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14492     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14493     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
14494       getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14495     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
14496               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14497               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
14498     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getCudaModuleCacheNV(
14499       VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14500 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14501 
14502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14503     VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo,
14504                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
14505                                                       VULKAN_HPP_NAMESPACE::CudaFunctionNV *                 pFunction,
14506                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14507 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14509     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>::type
14510       createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,
14511                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14512                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14513 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14515     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>>::type
14516       createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV &              createInfo,
14517                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14518                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14519 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
14520 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14521 
14522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14523     void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,
14524                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14525                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14526 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14527     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14528     void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,
14529                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14530                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14531 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14532 
14533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14534     void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                module,
14535                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14536                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14537 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14538     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14539     void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV                                  module,
14540                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14541                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14542 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14543 
14544     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14545     void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,
14546                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14547                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14548 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14550     void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,
14551                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14552                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14553 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14554 
14555     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14556     void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV              function,
14557                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14558                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14559 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14561     void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV                                function,
14562                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14563                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14564 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14565 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
14566 
14567 #if defined( VK_USE_PLATFORM_METAL_EXT )
14568     //=== VK_EXT_metal_objects ===
14569 
14570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14571     void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
14572                                 Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14573 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14575     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
14576                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14577     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14578     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14579                          exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14580 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14581 #endif   /*VK_USE_PLATFORM_METAL_EXT*/
14582 
14583     //=== VK_EXT_descriptor_buffer ===
14584 
14585     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14586     void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
14587                                         VULKAN_HPP_NAMESPACE::DeviceSize *        pLayoutSizeInBytes,
14588                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14590     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14591     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
14592                          getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
14593                                                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14594 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14595 
14596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14597     void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
14598                                                  uint32_t                                  binding,
14599                                                  VULKAN_HPP_NAMESPACE::DeviceSize *        pOffset,
14600                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14603     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
14604                          getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
14605                                                                  uint32_t                                  binding,
14606                                                                  Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14607 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14608 
14609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14610     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,
14611                            size_t                                             dataSize,
14612                            void *                                             pDescriptor,
14613                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14614 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14616     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
14617                            size_t                                             dataSize,
14618                            void *                                             pDescriptor,
14619                            Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14620     template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14621     VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
14622                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14623 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14624 
14625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14626     VULKAN_HPP_NODISCARD Result
14627       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo,
14628                                                void *                                                           pData,
14629                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14630 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14631     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14632     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14633       getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info,
14634                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14636 
14637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14638     VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo,
14639                                                                         void *                                                          pData,
14640                                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14642     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14643     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14644       getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info,
14645                                               Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14647 
14648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14649     VULKAN_HPP_NODISCARD Result
14650       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo,
14651                                                   void *                                                              pData,
14652                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14653 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14654     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14655     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14656       getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info,
14657                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14658 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14659 
14660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14661     VULKAN_HPP_NODISCARD Result
14662       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo,
14663                                                 void *                                                            pData,
14664                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14666     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14667     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14668       getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info,
14669                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14671 
14672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14673     VULKAN_HPP_NODISCARD Result
14674       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
14675                                                               void *                                                                          pData,
14676                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14677 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14678     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14679     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14680       getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info,
14681                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14682 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14683 
14684     //=== VK_EXT_device_fault ===
14685 
14686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14687     VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,
14688                                                  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT *   pFaultInfo,
14689                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14690 #if defined( VK_USE_PLATFORM_FUCHSIA )
14691     //=== VK_FUCHSIA_external_memory ===
14692 
14693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14694     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
14695                                                               zx_handle_t *                                                  pZirconHandle,
14696                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14697 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14698     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14699     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
14700       getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
14701                                     Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14702 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14703 
14704     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14705     VULKAN_HPP_NODISCARD Result
14706       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
14707                                               zx_handle_t                                                 zirconHandle,
14708                                               VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
14709                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14710 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14712     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
14713       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
14714                                               zx_handle_t                                            zirconHandle,
14715                                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14716 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14717 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
14718 
14719 #if defined( VK_USE_PLATFORM_FUCHSIA )
14720     //=== VK_FUCHSIA_external_semaphore ===
14721 
14722     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14723     VULKAN_HPP_NODISCARD Result
14724       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
14725                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14726 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14728     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14729       importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
14730                                           Dispatch const & d                                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14731 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14732 
14733     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14734     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
14735                                                                  zx_handle_t *                                                     pZirconHandle,
14736                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14737 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14739     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type
14740       getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
14741                                        Dispatch const & d                                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14742 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14743 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
14744 
14745 #if defined( VK_USE_PLATFORM_FUCHSIA )
14746     //=== VK_FUCHSIA_buffer_collection ===
14747 
14748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14749     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
14750                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
14751                                                                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,
14752                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14753 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14755     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type
14756       createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,
14757                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14758                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14759 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14761     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type
14762       createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA &     createInfo,
14763                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14764                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14765 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
14766 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14767 
14768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14769     VULKAN_HPP_NODISCARD Result
14770       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
14771                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
14772                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14773 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14774     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14775     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14776       setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
14777                                                   const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
14778                                                   Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14779 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14780 
14781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14782     VULKAN_HPP_NODISCARD Result
14783       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
14784                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
14785                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14786 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14787     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14788     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
14789       setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
14790                                                    const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
14791                                                    Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14792 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14793 
14794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14795     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
14796                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14797                                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14798 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14800     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,
14801                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14802                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14803 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14804 
14805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14806     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
14807                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14808                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14809 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14811     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA                       collection,
14812                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14813                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14814 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14815 
14816     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14817     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
14818                                                                       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
14819                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14820 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14822     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type
14823       getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
14824                                             Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14825 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14826 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
14827 
14828     //=== VK_HUAWEI_subpass_shading ===
14829 
14830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14831     VULKAN_HPP_NODISCARD Result
14832       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
14833                                                VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
14834                                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14837     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Extent2D>::type
14838       getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14839 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14840 
14841     //=== VK_NV_external_memory_rdma ===
14842 
14843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14844     VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
14845                                                           VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,
14846                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14849     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
14850       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
14851                                 Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14853 
14854     //=== VK_EXT_pipeline_properties ===
14855 
14856     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14857     VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo,
14858                                                           VULKAN_HPP_NAMESPACE::BaseOutStructure *      pPipelineProperties,
14859                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14862     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type
14863       getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14864 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14865 
14866     //=== VK_EXT_opacity_micromap ===
14867 
14868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14869     VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo,
14870                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
14871                                                    VULKAN_HPP_NAMESPACE::MicromapEXT *                 pMicromap,
14872                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14875     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type
14876       createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,
14877                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14878                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14879 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14880     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14881     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type
14882       createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT &                 createInfo,
14883                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14884                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14885 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
14886 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14887 
14888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14889     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,
14890                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14891                              Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14892 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14893     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14894     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14895                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14896                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14897 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14898 
14899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14900     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                 micromap,
14901                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14902                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14904     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14905     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT                                   micromap,
14906                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14907                   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     VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR         deferredOperation,
14912                                                    uint32_t                                           infoCount,
14913                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
14914                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14915 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14916     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14917     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
14918                          buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                 deferredOperation,
14919                                             VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
14920                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14921 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14922 
14923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14924     VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,
14925                                                  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
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 VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        deferredOperation,
14930                                                                        const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
14931                                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14932 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14933 
14934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14935     VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14936                                                          const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
14937                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14939     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14940     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14941                                                                                const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
14942                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14944 
14945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14946     VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14947                                                          const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
14948                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14949 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14950     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14951     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                deferredOperation,
14952                                                                                const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
14953                                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14954 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14955 
14956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14957     VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t                                  micromapCount,
14958                                                              const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
14959                                                              VULKAN_HPP_NAMESPACE::QueryType           queryType,
14960                                                              size_t                                    dataSize,
14961                                                              void *                                    pData,
14962                                                              size_t                                    stride,
14963                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14965     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14966     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
14967       writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
14968                                    VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
14969                                    size_t                                                                            dataSize,
14970                                    size_t                                                                            stride,
14971                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14972     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14973     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
14974       writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
14975                                  VULKAN_HPP_NAMESPACE::QueryType                                                   queryType,
14976                                  size_t                                                                            stride,
14977                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14978 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14979 
14980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14981     void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT *          pVersionInfo,
14982                                       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility,
14983                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14986     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
14987                          getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo,
14988                                                       Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14989 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14990 
14991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14992     void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
14993                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT *      pBuildInfo,
14994                                    VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT *       pSizeInfo,
14995                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14998     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
14999                          getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
15000                                                    const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT &      buildInfo,
15001                                                    Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15002 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15003 
15004     //=== VK_EXT_pageable_device_local_memory ===
15005 
15006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15007     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
15008                                float                              priority,
15009                                Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15010 
15011     //=== VK_KHR_maintenance4 ===
15012 
15013     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15014     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
15015                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                  pMemoryRequirements,
15016                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15017 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15018     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15019     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
15020                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
15021                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15022     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15023     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15024                          getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
15025                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15027 
15028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15029     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
15030                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
15031                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15032 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15034     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
15035                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
15036                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15037     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15038     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15039                          getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
15040                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15042 
15043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15044     void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
15045                                               uint32_t *                                                  pSparseMemoryRequirementCount,
15046                                               VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *      pSparseMemoryRequirements,
15047                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15049     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
15050               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15051     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
15052                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
15053                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15054     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
15055               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15056               typename std::enable_if<
15057                 std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
15058                 int>::type = 0>
15059     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
15060                          getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
15061                                                               SparseImageMemoryRequirements2Allocator &                   sparseImageMemoryRequirements2Allocator,
15062                                                               Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15063 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15064 
15065     //=== VK_VALVE_descriptor_set_host_mapping ===
15066 
15067     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15068     void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference,
15069                                                      VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE *  pHostMapping,
15070                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15073     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE
15074                          getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference,
15075                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15076 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15077 
15078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15079     void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
15080                                            void **                             ppData,
15081                                            Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15083     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15084     VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
15085                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15086 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15087 
15088     //=== VK_NV_device_generated_commands_compute ===
15089 
15090     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15091     void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo,
15092                                                   VULKAN_HPP_NAMESPACE::MemoryRequirements2 *             pMemoryRequirements,
15093                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15095     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15096     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
15097                          getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
15098                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15099     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15100     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15101                          getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
15102                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15103 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15104 
15105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15106     DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo,
15107                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15108 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15109     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15110     VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info,
15111                                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15112 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15113 
15114     //=== VK_EXT_shader_module_identifier ===
15115 
15116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15117     void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
15118                                        VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,
15119                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15120 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15121     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15122     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
15123                          getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
15124                                                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15126 
15127     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15128     void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
15129                                                  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT *    pIdentifier,
15130                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15131 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15132     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15133     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
15134                          getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
15135                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15137 
15138     //=== VK_NV_optical_flow ===
15139 
15140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15141     VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo,
15142                                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
15143                                                             VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV *                 pSession,
15144                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15145 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15147     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type
15148       createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,
15149                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15150                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15151 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
15152     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15153     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type
15154       createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV &        createInfo,
15155                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15156                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15157 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15158 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15159 
15160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15161     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,
15162                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15163                                       Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15166     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,
15167                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15168                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15170 
15171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15172     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV        session,
15173                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15174                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15176     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15177     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV                          session,
15178                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15179                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15181 
15182 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15184     VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
15185                                                                VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
15186                                                                VULKAN_HPP_NAMESPACE::ImageView                        view,
15187                                                                VULKAN_HPP_NAMESPACE::ImageLayout                      layout,
15188                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15189 #else
15190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15191     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
15192       bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV             session,
15193                                      VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
15194                                      VULKAN_HPP_NAMESPACE::ImageView                        view,
15195                                      VULKAN_HPP_NAMESPACE::ImageLayout                      layout,
15196                                      Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15197 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15198 
15199     //=== VK_KHR_maintenance5 ===
15200 
15201     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15202     void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo * pRenderingAreaInfo,
15203                                          VULKAN_HPP_NAMESPACE::Extent2D *                pGranularity,
15204                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15207     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
15208                          getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo,
15209                                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15211 
15212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15213     void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo * pInfo,
15214                                        VULKAN_HPP_NAMESPACE::SubresourceLayout2 *               pLayout,
15215                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15216 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15218     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2
15219                          getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info,
15220                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15221     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15222     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15223                          getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info,
15224                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15226 
15227     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15228     void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                     image,
15229                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2 * pSubresource,
15230                                         VULKAN_HPP_NAMESPACE::SubresourceLayout2 *      pLayout,
15231                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15233     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15234     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2
15235                          getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                     image,
15236                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource,
15237                                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15238     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15239     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15240                          getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image                     image,
15241                                                         const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource,
15242                                                         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15243 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15244 
15245     //=== VK_AMD_anti_lag ===
15246 
15247     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15248     void antiLagUpdateAMD( const VULKAN_HPP_NAMESPACE::AntiLagDataAMD * pData,
15249                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15250 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15251     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15252     void antiLagUpdateAMD( const VULKAN_HPP_NAMESPACE::AntiLagDataAMD & data,
15253                            Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15254 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15255 
15256     //=== VK_EXT_shader_object ===
15257 
15258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15259     VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t                                          createInfoCount,
15260                                                   const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos,
15261                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15262                                                   VULKAN_HPP_NAMESPACE::ShaderEXT *                 pShaders,
15263                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15264 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15265     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15266     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>
15267                          createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
15268                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15269                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15270     template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>,
15271               typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15272               typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>
15273     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT, ShaderEXTAllocator>>
15274                          createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
15275                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
15276                                            ShaderEXTAllocator &                                                                      shaderEXTAllocator,
15277                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15278     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15279     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::ShaderEXT>
15280                          createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,
15281                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15282                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15283 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
15284     template <typename Dispatch           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15285               typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>>
15286     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>
15287                          createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
15288                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15289                                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15290     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15291               typename ShaderEXTAllocator        = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,
15292               typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value,
15293                                       int>::type = 0>
15294     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator>>
15295                          createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
15296                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                                 allocator,
15297                                                  ShaderEXTAllocator &                                                                      shaderEXTAllocator,
15298                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15300     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>
15301                          createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT &                   createInfo,
15302                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15303                                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15304 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15305 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15306 
15307     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15308     void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,
15309                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15310                            Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15312     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15313     void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15314                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15315                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15316 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15317 
15318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15319     void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                   shader,
15320                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15321                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15322 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15324     void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT                                     shader,
15325                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15326                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15327 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15328 
15329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15330     VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
15331                                                         size_t *                        pDataSize,
15332                                                         void *                          pData,
15333                                                         Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15335     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15336     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
15337       getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15338     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
15339               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15340               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
15341     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderBinaryDataEXT(
15342       VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15344 
15345     //=== VK_KHR_pipeline_binary ===
15346 
15347     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15348     VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR * pCreateInfo,
15349                                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
15350                                                            VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR *      pBinaries,
15351                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15353     template <typename PipelineBinaryKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>,
15354               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15355     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
15356                          createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR &           createInfo,
15357                                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15358                                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15359     template <
15360       typename PipelineBinaryKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>,
15361       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15362       typename std::enable_if<std::is_same<typename PipelineBinaryKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>::value, int>::type = 0>
15363     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, PipelineBinaryKHRAllocator>>
15364                          createPipelineBinariesKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
15365                                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
15366                                                     PipelineBinaryKHRAllocator &                              pipelineBinaryKHRAllocator,
15367                                                     Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15368 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
15369     template <typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15370               typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>>
15371     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
15372                          createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR &           createInfo,
15373                                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15374                                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15375     template <typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15376               typename PipelineBinaryKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>,
15377               typename std::enable_if<
15378                 std::is_same<typename PipelineBinaryKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>>::value,
15379                 int>::type = 0>
15380     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator>>
15381                          createPipelineBinariesKHRUnique( const VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR & createInfo,
15382                                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
15383                                                           PipelineBinaryKHRAllocator &                              pipelineBinaryKHRAllocator,
15384                                                           Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15385 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15386 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15387 
15388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15389     void destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR           pipelineBinary,
15390                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15391                                    Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15393     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15394     void destroyPipelineBinaryKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR pipelineBinary              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15395                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15396                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15397 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15398 
15399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15400     void destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR           pipelineBinary,
15401                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15402                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15405     void destroy( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR                             pipelineBinary,
15406                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15407                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15409 
15410     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15411     VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR * pPipelineCreateInfo,
15412                                                    VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR *        pPipelineKey,
15413                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15414 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15416     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR>::type
15417       getPipelineKeyKHR( Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15418                          Dispatch const & d                                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15419 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15420 
15421     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15422     VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR * pInfo,
15423                                                           VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR *            pPipelineBinaryKey,
15424                                                           size_t *                                                pPipelineBinaryDataSize,
15425                                                           void *                                                  pPipelineBinaryData,
15426                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15428     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15429     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
15430       getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info,
15431                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15432     template <typename Uint8_tAllocator                                                                               = std::allocator<uint8_t>,
15433               typename Dispatch                                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15434               typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
15435     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t, Uint8_tAllocator>>>::type
15436       getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info,
15437                                 Uint8_tAllocator &                                      uint8_tAllocator,
15438                                 Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15439 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15440 
15441     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15442     Result releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR * pInfo,
15443                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
15444                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15445 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15446     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15447     void releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR &    info,
15448                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15449                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15450 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15451 
15452     //=== VK_QCOM_tile_properties ===
15453 
15454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15455     VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer          framebuffer,
15456                                                                   uint32_t *                                 pPropertiesCount,
15457                                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,
15458                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15459 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15460     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
15461               typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15462     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
15463       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15464     template <
15465       typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
15466       typename Dispatch                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15467       typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>
15468     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type
15469       getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
15470                                         TilePropertiesQCOMAllocator &     tilePropertiesQCOMAllocator,
15471                                         Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15473 
15474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15475     Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
15476                                                   VULKAN_HPP_NAMESPACE::TilePropertiesQCOM *  pProperties,
15477                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15480     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
15481                          getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
15482                                                                 Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15483 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15484 
15485     //=== VK_NV_low_latency2 ===
15486 
15487     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15488     VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
15489                                                        const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
15490                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15492     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15493     typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
15494                                                                 const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,
15495                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15497 
15498     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15499     Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,
15500                            const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
15501                            Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15503     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15504     void latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR               swapchain,
15505                          const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo,
15506                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15507 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15508 
15509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15510     void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
15511                              const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
15512                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15515     void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
15516                              const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,
15517                              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15519 
15520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15521     void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR             swapchain,
15522                               VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
15523                               Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15525     template <typename LatencyTimingsFrameReportNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>,
15526               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15527     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
15528                          getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15529     template <
15530       typename LatencyTimingsFrameReportNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>,
15531       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15532       typename std::enable_if<std::is_same<typename LatencyTimingsFrameReportNVAllocator::value_type, VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV>::value,
15533                               int>::type            = 0>
15534     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV, LatencyTimingsFrameReportNVAllocator>
15535                          getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR     swapchain,
15536                                               LatencyTimingsFrameReportNVAllocator & latencyTimingsFrameReportNVAllocator,
15537                                               Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15538 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15539 
15540 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
15541     //=== VK_QNX_external_memory_screen_buffer ===
15542 
15543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15544     VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer *                     buffer,
15545                                                               VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties,
15546                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15547 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15549     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>::type
15550       getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15551     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15552     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15553       getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15554 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15555 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
15556 
15557     //=== VK_KHR_calibrated_timestamps ===
15558 
15559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15560     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t                                                 timestampCount,
15561                                                             const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
15562                                                             uint64_t *                                               pTimestamps,
15563                                                             uint64_t *                                               pMaxDeviation,
15564                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15566     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15567     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
15568       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
15569                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15570     template <typename Uint64_tAllocator                                                                                = std::allocator<uint64_t>,
15571               typename Dispatch                                                                                         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15572               typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
15573     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
15574       getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
15575                                   Uint64_tAllocator &                                                                              uint64_tAllocator,
15576                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15578     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
15579       getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
15580                                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15581 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15582 
operator VkDevice() const15583     operator VkDevice() const VULKAN_HPP_NOEXCEPT
15584     {
15585       return m_device;
15586     }
15587 
operator bool() const15588     explicit operator bool() const VULKAN_HPP_NOEXCEPT
15589     {
15590       return m_device != VK_NULL_HANDLE;
15591     }
15592 
operator !() const15593     bool operator!() const VULKAN_HPP_NOEXCEPT
15594     {
15595       return m_device == VK_NULL_HANDLE;
15596     }
15597 
15598   private:
15599     VkDevice m_device = {};
15600   };
15601 
15602   template <>
15603   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
15604   {
15605     using Type = VULKAN_HPP_NAMESPACE::Device;
15606   };
15607 
15608   template <>
15609   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
15610   {
15611     using Type = VULKAN_HPP_NAMESPACE::Device;
15612   };
15613 
15614 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
15615   template <>
15616   struct CppType<VkDevice, VK_NULL_HANDLE>
15617   {
15618     using Type = VULKAN_HPP_NAMESPACE::Device;
15619   };
15620 #endif
15621 
15622   template <>
15623   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
15624   {
15625     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
15626   };
15627 
15628   class DisplayModeKHR
15629   {
15630   public:
15631     using CType      = VkDisplayModeKHR;
15632     using NativeType = VkDisplayModeKHR;
15633 
15634     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
15635     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
15636       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
15637 
15638   public:
DisplayModeKHR()15639     DisplayModeKHR() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
15640     DisplayModeKHR( DisplayModeKHR const & rhs )             = default;
15641     DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
15642 
15643 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
15644     DisplayModeKHR( DisplayModeKHR && rhs )             = default;
15645     DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;
15646 #else
DisplayModeKHR(DisplayModeKHR && rhs)15647     DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) {}
15648 
operator =(DisplayModeKHR && rhs)15649     DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
15650     {
15651       m_displayModeKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );
15652       return *this;
15653     }
15654 #endif
15655 
DisplayModeKHR(std::nullptr_t)15656     VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
15657 
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)15658     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
15659 
15660 #if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
operator =(VkDisplayModeKHR displayModeKHR)15661     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
15662     {
15663       m_displayModeKHR = displayModeKHR;
15664       return *this;
15665     }
15666 #endif
15667 
operator =(std::nullptr_t)15668     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
15669     {
15670       m_displayModeKHR = {};
15671       return *this;
15672     }
15673 
15674 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
15675     auto operator<=>( DisplayModeKHR const & ) const = default;
15676 #else
operator ==(DisplayModeKHR const & rhs) const15677     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
15678     {
15679       return m_displayModeKHR == rhs.m_displayModeKHR;
15680     }
15681 
operator !=(DisplayModeKHR const & rhs) const15682     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
15683     {
15684       return m_displayModeKHR != rhs.m_displayModeKHR;
15685     }
15686 
operator <(DisplayModeKHR const & rhs) const15687     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
15688     {
15689       return m_displayModeKHR < rhs.m_displayModeKHR;
15690     }
15691 #endif
15692 
operator VkDisplayModeKHR() const15693     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
15694     {
15695       return m_displayModeKHR;
15696     }
15697 
operator bool() const15698     explicit operator bool() const VULKAN_HPP_NOEXCEPT
15699     {
15700       return m_displayModeKHR != VK_NULL_HANDLE;
15701     }
15702 
operator !() const15703     bool operator!() const VULKAN_HPP_NOEXCEPT
15704     {
15705       return m_displayModeKHR == VK_NULL_HANDLE;
15706     }
15707 
15708   private:
15709     VkDisplayModeKHR m_displayModeKHR = {};
15710   };
15711 
15712   template <>
15713   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
15714   {
15715     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
15716   };
15717 
15718   template <>
15719   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
15720   {
15721     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
15722   };
15723 
15724 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
15725   template <>
15726   struct CppType<VkDisplayModeKHR, VK_NULL_HANDLE>
15727   {
15728     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
15729   };
15730 #endif
15731 
15732   template <>
15733   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
15734   {
15735     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
15736   };
15737 
15738   class PhysicalDevice
15739   {
15740   public:
15741     using CType      = VkPhysicalDevice;
15742     using NativeType = VkPhysicalDevice;
15743 
15744     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
15745     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
15746       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
15747 
15748   public:
PhysicalDevice()15749     PhysicalDevice() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
15750     PhysicalDevice( PhysicalDevice const & rhs )             = default;
15751     PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
15752 
15753 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
15754     PhysicalDevice( PhysicalDevice && rhs )             = default;
15755     PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;
15756 #else
PhysicalDevice(PhysicalDevice && rhs)15757     PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) {}
15758 
operator =(PhysicalDevice && rhs)15759     PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
15760     {
15761       m_physicalDevice = VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
15762       return *this;
15763     }
15764 #endif
15765 
PhysicalDevice(std::nullptr_t)15766     VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
15767 
PhysicalDevice(VkPhysicalDevice physicalDevice)15768     PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
15769 
operator =(VkPhysicalDevice physicalDevice)15770     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
15771     {
15772       m_physicalDevice = physicalDevice;
15773       return *this;
15774     }
15775 
operator =(std::nullptr_t)15776     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
15777     {
15778       m_physicalDevice = {};
15779       return *this;
15780     }
15781 
15782 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
15783     auto operator<=>( PhysicalDevice const & ) const = default;
15784 #else
operator ==(PhysicalDevice const & rhs) const15785     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
15786     {
15787       return m_physicalDevice == rhs.m_physicalDevice;
15788     }
15789 
operator !=(PhysicalDevice const & rhs) const15790     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
15791     {
15792       return m_physicalDevice != rhs.m_physicalDevice;
15793     }
15794 
operator <(PhysicalDevice const & rhs) const15795     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
15796     {
15797       return m_physicalDevice < rhs.m_physicalDevice;
15798     }
15799 #endif
15800 
15801     //=== VK_VERSION_1_0 ===
15802 
15803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15804     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
15805                       Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15806 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15808     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
15809                          getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15810 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15811 
15812     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15813     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
15814                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
15815                               Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15816 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15818     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
15819       getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15821 
15822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15823     VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
15824                                                           VULKAN_HPP_NAMESPACE::ImageType               type,
15825                                                           VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
15826                                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
15827                                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
15828                                                           VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
15829                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15832     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
15833       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
15834                                 VULKAN_HPP_NAMESPACE::ImageType              type,
15835                                 VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
15836                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
15837                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15838                                 Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15839 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15840 
15841     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15842     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
15843                         Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15844 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15846     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
15847                          getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15848 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15849 
15850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15851     void getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
15852                                    VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
15853                                    Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15855     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
15856               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15857     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
15858                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15859     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
15860               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15861               typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
15862                                       int>::type      = 0>
15863     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
15864                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
15865                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15866 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15867 
15868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15869     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
15870                               Dispatch const & d                                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15871 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15873     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
15874                          getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15875 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15876 
15877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15878     VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
15879                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15880                                               VULKAN_HPP_NAMESPACE::Device *                    pDevice,
15881                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15882 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15884     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
15885       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,
15886                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15887                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15888 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
15889     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15890     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
15891       createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo &                      createInfo,
15892                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15893                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15894 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
15895 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15896 
15897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15898     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char *                                pLayerName,
15899                                                                     uint32_t *                                  pPropertyCount,
15900                                                                     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
15901                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15903     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
15904               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15905     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
15906       enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
15907                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15908     template <
15909       typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
15910       typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15911       typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
15912     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
15913       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
15914                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
15915                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15917 
15918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15919     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t *                              pPropertyCount,
15920                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
15921                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15922 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15923     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15924     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
15925       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15926     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
15927               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15928               typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
15929     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
15930       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15932 
15933     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15934     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
15935                                          VULKAN_HPP_NAMESPACE::ImageType                     type,
15936                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
15937                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
15938                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
15939                                          uint32_t *                                          pPropertyCount,
15940                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
15941                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15943     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
15944               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15945     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
15946                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
15947                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
15948                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
15949                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
15950                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
15951                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15952     template <
15953       typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
15954       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15955       typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
15956                               int>::type            = 0>
15957     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
15958                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
15959                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
15960                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
15961                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
15962                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
15963                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
15964                                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15965 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15966 
15967     //=== VK_VERSION_1_1 ===
15968 
15969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15970     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
15971                        Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15972 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15973     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15974     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
15975                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15976     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15977     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15978                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15979 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15980 
15981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15982     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
15983                          Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15986     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
15987                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15988     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15989     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15990                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15991 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15992 
15993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15994     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
15995                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
15996                                Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
15997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15998     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15999     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
16000       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16001     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16002     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16003       getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16005 
16006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16007     VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
16008                                                            VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
16009                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16010 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16012     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
16013       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
16014                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16015     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16016     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
16017       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
16018                                  Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16019 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16020 
16021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16022     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
16023                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
16024                                     Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16026     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
16027               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16028     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
16029                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16030     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
16031               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16032               typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
16033                                       int>::type       = 0>
16034     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
16035                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
16036                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16037     template <typename StructureChain,
16038               typename StructureChainAllocator = std::allocator<StructureChain>,
16039               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16040     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
16041                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16042     template <typename StructureChain,
16043               typename StructureChainAllocator = std::allocator<StructureChain>,
16044               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16045               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
16046     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
16047       getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16048 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16049 
16050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16051     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
16052                                Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16053 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16054     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16055     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
16056                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16057     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16058     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16059                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16060 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16061 
16062     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16063     void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
16064                                           uint32_t *                                                         pPropertyCount,
16065                                           VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
16066                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16068     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
16069               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16070     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
16071                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
16072                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16073     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
16074               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16075               typename std::enable_if<
16076                 std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
16077                 int>::type = 0>
16078     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
16079                          getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
16080                                                           SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
16081                                                           Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16083 
16084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16085     void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
16086                                       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
16087                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16088 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16089     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16090     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
16091                          getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
16092                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16094 
16095     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16096     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
16097                                      VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
16098                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16101     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
16102                          getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
16103                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16104 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16105 
16106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16107     void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
16108                                          VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
16109                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16112     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
16113                          getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
16114                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16115 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16116 
16117     //=== VK_VERSION_1_3 ===
16118 
16119     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16120     VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t *                                           pToolCount,
16121                                                    VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
16122                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16123 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16124     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
16125               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16126     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
16127       getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16128     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
16129               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16130               typename std::enable_if<
16131                 std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
16132                 int>::type = 0>
16133     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
16134       getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
16135                          Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16137 
16138     //=== VK_KHR_surface ===
16139 
16140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16141     VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
16142                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
16143                                                       VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
16144                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16145 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16147     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR(
16148       uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16149 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16150 
16151     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16152     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
16153                                                            VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
16154                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16157     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
16158       getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16159 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16160 
16161     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16162     VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
16163                                                       uint32_t *                               pSurfaceFormatCount,
16164                                                       VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
16165                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16167     template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
16168               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16169     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
16170       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16171                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16172     template <
16173       typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
16174       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16175       typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>
16176     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
16177       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
16178                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
16179                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16181 
16182     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16183     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
16184                                                            uint32_t *                             pPresentModeCount,
16185                                                            VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
16186                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16187 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16188     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16189     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
16190       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16191                                  Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16192     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
16193               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16194               typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
16195     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
16196       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
16197                                  PresentModeKHRAllocator &        presentModeKHRAllocator,
16198                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16200 
16201     //=== VK_KHR_swapchain ===
16202 
16203     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16204     VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
16205                                                          uint32_t *                       pRectCount,
16206                                                          VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
16207                                                          Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16208 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16209     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16210     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type
16211       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16212     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,
16213               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16214               typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>
16215     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR(
16216       VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16218 
16219     //=== VK_KHR_display ===
16220 
16221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16222     VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
16223                                                          VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
16224                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16226     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
16227               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16228     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
16229       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16230     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
16231               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16232               typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
16233                                       int>::type     = 0>
16234     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
16235       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
16236                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16238 
16239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16240     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t *                                        pPropertyCount,
16241                                                               VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
16242                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16243 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16244     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
16245               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16246     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
16247       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16248     template <
16249       typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
16250       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16251       typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
16252                               int>::type          = 0>
16253     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
16254       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
16255                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16256 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16257 
16258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16259     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t                           planeIndex,
16260                                                                      uint32_t *                         pDisplayCount,
16261                                                                      VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
16262                                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16264     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16265     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type
16266       getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16267     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,
16268               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16269               typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>
16270     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR(
16271       uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16272 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16273 
16274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16275     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
16276                                                              uint32_t *                                       pPropertyCount,
16277                                                              VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
16278                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16280     template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
16281               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16282     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
16283       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16284     template <
16285       typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
16286       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16287       typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
16288                               int>::type         = 0>
16289     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
16290       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
16291                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
16292                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16293 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16294 
16295     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16296     VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
16297                                                       const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
16298                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
16299                                                       VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
16300                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16303     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
16304       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
16305                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,
16306                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16307                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16308 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16309     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16310     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
16311       createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                                    display,
16312                                   const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR &              createInfo,
16313                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
16314                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16315 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16316 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16317 
16318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16319     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
16320                                                                 uint32_t                                            planeIndex,
16321                                                                 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
16322                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16323 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16324     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16325     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR(
16326       VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16327 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16328 
16329 #if defined( VK_USE_PLATFORM_XLIB_KHR )
16330     //=== VK_KHR_xlib_surface ===
16331 
16332     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16333     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
16334                                           Display *          dpy,
16335                                           VisualID           visualID,
16336                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16337 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16339     VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
16340                                                                 Display &          dpy,
16341                                                                 VisualID           visualID,
16342                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16343 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16344 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/
16345 
16346 #if defined( VK_USE_PLATFORM_XCB_KHR )
16347     //=== VK_KHR_xcb_surface ===
16348 
16349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16350     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
16351                                          xcb_connection_t * connection,
16352                                          xcb_visualid_t     visual_id,
16353                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16354 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16356     VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
16357                                                                xcb_connection_t & connection,
16358                                                                xcb_visualid_t     visual_id,
16359                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16360 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16361 #endif   /*VK_USE_PLATFORM_XCB_KHR*/
16362 
16363 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
16364     //=== VK_KHR_wayland_surface ===
16365 
16366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16367     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
16368                                              struct wl_display * display,
16369                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16370 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16372     VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
16373                                                                    struct wl_display & display,
16374                                                                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16375 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16376 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
16377 
16378 #if defined( VK_USE_PLATFORM_WIN32_KHR )
16379     //=== VK_KHR_win32_surface ===
16380 
16381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16382     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16383 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
16384 
16385     //=== VK_KHR_video_queue ===
16386 
16387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16388     VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,
16389                                                          VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *      pCapabilities,
16390                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16393     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
16394       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
16395                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16396     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16397     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
16398       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
16399                                Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16400 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16401 
16402     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16403     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
16404                                                              uint32_t *                                                     pVideoFormatPropertyCount,
16405                                                              VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
16406                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16407 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16408     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
16409               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16410     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
16411       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
16412                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16413     template <
16414       typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
16415       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16416       typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value,
16417                               int>::type         = 0>
16418     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
16419       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
16420                                    VideoFormatPropertiesKHRAllocator &                            videoFormatPropertiesKHRAllocator,
16421                                    Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16422 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16423 
16424     //=== VK_NV_external_memory_capabilities ===
16425 
16426     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16427     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                            format,
16428                                                                     VULKAN_HPP_NAMESPACE::ImageType                         type,
16429                                                                     VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
16430                                                                     VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
16431                                                                     VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
16432                                                                     VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
16433                                                                     VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
16434                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16435 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16437     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
16438       getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format                                             format,
16439                                           VULKAN_HPP_NAMESPACE::ImageType                                          type,
16440                                           VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
16441                                           VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
16442                                           VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16443                                           VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
16444                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16446 
16447     //=== VK_KHR_get_physical_device_properties2 ===
16448 
16449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16450     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
16451                           Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16452 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16453     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16454     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
16455                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16456     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16457     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16458                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16459 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16460 
16461     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16462     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
16463                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16466     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
16467                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16468     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16469     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16470                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16472 
16473     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16474     void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
16475                                   VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
16476                                   Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16479     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
16480       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16481     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16482     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16483       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16485 
16486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16487     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
16488                                                               VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
16489                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16492     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
16493       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
16494                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16495     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16496     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
16497       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
16498                                     Dispatch const & d                                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16499 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16500 
16501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16502     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
16503                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
16504                                        Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16506     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
16507               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16508     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
16509                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16510     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
16511               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16512               typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
16513                                       int>::type       = 0>
16514     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
16515                          getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
16516                                                        Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16517     template <typename StructureChain,
16518               typename StructureChainAllocator = std::allocator<StructureChain>,
16519               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16520     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
16521                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16522     template <typename StructureChain,
16523               typename StructureChainAllocator = std::allocator<StructureChain>,
16524               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16525               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
16526     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
16527       getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16528 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16529 
16530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16531     void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
16532                                   Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16533 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16535     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
16536                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16537     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16538     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16539                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16540 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16541 
16542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16543     void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
16544                                              uint32_t *                                                         pPropertyCount,
16545                                              VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
16546                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16547 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16548     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
16549               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16550     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
16551                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
16552                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16553     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
16554               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16555               typename std::enable_if<
16556                 std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
16557                 int>::type = 0>
16558     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
16559                          getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
16560                                                              SparseImageFormatProperties2Allocator &                            sparseImageFormatProperties2Allocator,
16561                                                              Dispatch const & d                                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16563 
16564     //=== VK_KHR_external_memory_capabilities ===
16565 
16566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16567     void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
16568                                          VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
16569                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16572     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
16573                          getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
16574                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16575 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16576 
16577     //=== VK_KHR_external_semaphore_capabilities ===
16578 
16579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16580     void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
16581                                             VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
16582                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16585     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
16586                          getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
16587                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16588 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16589 
16590     //=== VK_EXT_direct_mode_display ===
16591 
16592 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
16593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16594     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16595 #else
16596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16597     void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16598 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
16599 
16600 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
16601     //=== VK_EXT_acquire_xlib_display ===
16602 
16603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16604     VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display *                        dpy,
16605                                                        VULKAN_HPP_NAMESPACE::DisplayKHR display,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
16610       acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16611 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16612 
16613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16614     VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display *                          dpy,
16615                                                           RROutput                           rrOutput,
16616                                                           VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
16617                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16618 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16619     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16620     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
16621       getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16622 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
16623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16624     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
16625       getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16626 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
16627 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16628 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
16629 
16630     //=== VK_EXT_display_surface_counter ===
16631 
16632     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16633     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
16634                                                             VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
16635                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16638     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
16639       getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16640 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16641 
16642     //=== VK_KHR_external_fence_capabilities ===
16643 
16644     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16645     void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
16646                                         VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
16647                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16648 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16650     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
16651                          getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
16652                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16653 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16654 
16655     //=== VK_KHR_performance_query ===
16656 
16657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16658     VULKAN_HPP_NODISCARD Result
16659       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                                 queueFamilyIndex,
16660                                                        uint32_t *                                               pCounterCount,
16661                                                        VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
16662                                                        VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
16663                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16664 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16665     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
16666               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
16667               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16668     VULKAN_HPP_NODISCARD
16669       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
16670                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
16671       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16672     template <typename PerformanceCounterKHRAllocator            = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
16673               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
16674               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16675               typename std::enable_if<
16676                 std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
16677                   std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
16678                 int>::type = 0>
16679     VULKAN_HPP_NODISCARD
16680       typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
16681                                          std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
16682       enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t                                    queueFamilyIndex,
16683                                                        PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
16684                                                        PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
16685                                                        Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16686 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16687 
16688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16689     void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
16690                                                   uint32_t *                                                      pNumPasses,
16691                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16694     VULKAN_HPP_NODISCARD uint32_t
16695       getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
16696                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16697 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16698 
16699     //=== VK_KHR_get_surface_capabilities2 ===
16700 
16701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16702     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
16703                                                             VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
16704                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16706     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16707     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
16708       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16709                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16710     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16711     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
16712       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16713                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16714 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16715 
16716     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16717     VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
16718                                                        uint32_t *                                                  pSurfaceFormatCount,
16719                                                        VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
16720                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16721 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16722     template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
16723               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16724     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
16725       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16726                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16727     template <
16728       typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
16729       typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16730       typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>
16731     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
16732       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16733                              SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
16734                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16735     template <typename StructureChain,
16736               typename StructureChainAllocator = std::allocator<StructureChain>,
16737               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16738     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
16739       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16740                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16741     template <typename StructureChain,
16742               typename StructureChainAllocator = std::allocator<StructureChain>,
16743               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16744               typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
16745     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type
16746       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16747                              StructureChainAllocator &                                   structureChainAllocator,
16748                              Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16750 
16751     //=== VK_KHR_get_display_properties2 ===
16752 
16753     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16754     VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
16755                                                           VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
16756                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16757 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16758     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
16759               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16760     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
16761       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16762     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
16763               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16764               typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value,
16765                                       int>::type      = 0>
16766     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
16767       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
16768                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16769 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16770 
16771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16772     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
16773                                                                VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
16774                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16776     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
16777               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16778     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
16779       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16780     template <
16781       typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
16782       typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16783       typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value,
16784                               int>::type           = 0>
16785     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
16786       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
16787                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16788 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16789 
16790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16791     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
16792                                                               uint32_t *                                        pPropertyCount,
16793                                                               VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
16794                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16795 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16796     template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
16797               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16798     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
16799       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16800     template <
16801       typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
16802       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16803       typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value,
16804                               int>::type          = 0>
16805     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
16806       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
16807                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
16808                                     Dispatch const & d                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16809 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16810 
16811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16812     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
16813                                                                  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
16814                                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16816     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16817     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
16818       getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,
16819                                        Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16821 
16822     //=== VK_EXT_sample_locations ===
16823 
16824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16825     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
16826                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
16827                                       Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16828 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16830     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
16831                          getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
16832                                                       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16833 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16834 
16835     //=== VK_EXT_calibrated_timestamps ===
16836 
16837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16838     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t *                            pTimeDomainCount,
16839                                                                 VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
16840                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16841 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16842     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16843     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
16844       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16845     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
16846               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16847               typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
16848     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
16849       getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16850 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16851 
16852     //=== VK_KHR_fragment_shading_rate ===
16853 
16854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16855     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t *                                                   pFragmentShadingRateCount,
16856                                                             VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
16857                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16859     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
16860               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16861     VULKAN_HPP_NODISCARD
16862       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
16863       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16864     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
16865               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16866               typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type,
16867                                                    VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value,
16868                                       int>::type                     = 0>
16869     VULKAN_HPP_NODISCARD
16870       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
16871       getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
16872                                   Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16873 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16874 
16875     //=== VK_EXT_tooling_info ===
16876 
16877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16878     VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t *                                           pToolCount,
16879                                                       VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
16880                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16881 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16882     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
16883               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16884     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
16885       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16886     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
16887               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16888               typename std::enable_if<
16889                 std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
16890                 int>::type = 0>
16891     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type
16892       getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
16893                             Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16894 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16895 
16896     //=== VK_NV_cooperative_matrix ===
16897 
16898     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16899     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t *                                            pPropertyCount,
16900                                                                   VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
16901                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16903     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
16904               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16905     VULKAN_HPP_NODISCARD
16906       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
16907       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16908     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
16909               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16910               typename std::enable_if<
16911                 std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value,
16912                 int>::type = 0>
16913     VULKAN_HPP_NODISCARD
16914       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
16915       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
16916                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16917 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16918 
16919     //=== VK_NV_coverage_reduction_mode ===
16920 
16921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16922     VULKAN_HPP_NODISCARD Result
16923       getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t *                                                   pCombinationCount,
16924                                                          VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
16925                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16926 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16927     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
16928               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16929     VULKAN_HPP_NODISCARD
16930       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
16931       getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16932     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
16933               typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16934               typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type,
16935                                                    VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value,
16936                                       int>::type                     = 0>
16937     VULKAN_HPP_NODISCARD
16938       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
16939       getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
16940                                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16941 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16942 
16943 #if defined( VK_USE_PLATFORM_WIN32_KHR )
16944     //=== VK_EXT_full_screen_exclusive ===
16945 
16946     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16947     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
16948                                                             uint32_t *                                                  pPresentModeCount,
16949                                                             VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
16950                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16951 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16952     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16953     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
16954       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16955                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16956     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
16957               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16958               typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
16959     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type
16960       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
16961                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,
16962                                   Dispatch const & d                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16963 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16964 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
16965 
16966     //=== VK_EXT_acquire_drm_display ===
16967 
16968 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
16969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16970     VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t                          drmFd,
16971                                                       VULKAN_HPP_NAMESPACE::DisplayKHR display,
16972                                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16973 #else
16974     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16975     typename ResultValueType<void>::type
16976       acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16977 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
16978 
16979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16980     VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t                            drmFd,
16981                                                   uint32_t                           connectorId,
16982                                                   VULKAN_HPP_NAMESPACE::DisplayKHR * display,
16983                                                   Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
16984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16986     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
16987       getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16988 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
16989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16990     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
16991       getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16992 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
16993 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16994 
16995     //=== VK_KHR_video_encode_queue ===
16996 
16997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16998     VULKAN_HPP_NODISCARD Result
16999       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
17000                                                VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR *               pQualityLevelProperties,
17001                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17002 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17003     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17004     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>::type
17005       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
17006                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17007     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17008     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
17009       getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
17010                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17011 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17012 
17013 #if defined( VK_USE_PLATFORM_WIN32_KHR )
17014     //=== VK_NV_acquire_winrt_display ===
17015 
17016 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
17017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17018     VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
17019                                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17020 #  else
17021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17022     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
17023       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17024 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
17025 
17026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17027     VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t                           deviceRelativeId,
17028                                                    VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
17029                                                    Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17030 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17031     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17032     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
17033       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17034 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17035     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17036     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
17037       getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17038 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17039 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17040 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
17041 
17042 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
17043     //=== VK_EXT_directfb_surface ===
17044 
17045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17046     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
17047                                               IDirectFB *        dfb,
17048                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17049 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17051     VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
17052                                                                     IDirectFB &        dfb,
17053                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17054 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17055 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
17056 
17057 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
17058     //=== VK_QNX_screen_surface ===
17059 
17060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17061     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
17062                                             struct _screen_window * window,
17063                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17064 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17066     VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
17067                                                                   struct _screen_window & window,
17068                                                                   Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17069 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17070 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
17071 
17072     //=== VK_NV_optical_flow ===
17073 
17074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17075     VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
17076                                                               uint32_t *                                                 pFormatCount,
17077                                                               VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
17078                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17079 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17080     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
17081               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17082     VULKAN_HPP_NODISCARD
17083       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
17084       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
17085                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17086     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
17087               typename Dispatch                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17088               typename std::enable_if<
17089                 std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value,
17090                 int>::type = 0>
17091     VULKAN_HPP_NODISCARD
17092       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type
17093       getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
17094                                     OpticalFlowImageFormatPropertiesNVAllocator &              opticalFlowImageFormatPropertiesNVAllocator,
17095                                     Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17096 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17097 
17098     //=== VK_KHR_cooperative_matrix ===
17099 
17100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17101     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t *                                             pPropertyCount,
17102                                                                    VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties,
17103                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17104 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17105     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
17106               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17107     VULKAN_HPP_NODISCARD
17108       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
17109       getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17110     template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
17111               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17112               typename std::enable_if<
17113                 std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value,
17114                 int>::type = 0>
17115     VULKAN_HPP_NODISCARD
17116       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator>>::type
17117       getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
17118                                          Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17120 
17121     //=== VK_KHR_calibrated_timestamps ===
17122 
17123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17124     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t *                            pTimeDomainCount,
17125                                                                 VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
17126                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17127 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17128     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17129     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
17130       getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17131     template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
17132               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17133               typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
17134     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
17135       getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17136 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17137 
operator VkPhysicalDevice() const17138     operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
17139     {
17140       return m_physicalDevice;
17141     }
17142 
operator bool() const17143     explicit operator bool() const VULKAN_HPP_NOEXCEPT
17144     {
17145       return m_physicalDevice != VK_NULL_HANDLE;
17146     }
17147 
operator !() const17148     bool operator!() const VULKAN_HPP_NOEXCEPT
17149     {
17150       return m_physicalDevice == VK_NULL_HANDLE;
17151     }
17152 
17153   private:
17154     VkPhysicalDevice m_physicalDevice = {};
17155   };
17156 
17157   template <>
17158   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
17159   {
17160     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
17161   };
17162 
17163   template <>
17164   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
17165   {
17166     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
17167   };
17168 
17169 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
17170   template <>
17171   struct CppType<VkPhysicalDevice, VK_NULL_HANDLE>
17172   {
17173     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
17174   };
17175 #endif
17176 
17177   template <>
17178   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
17179   {
17180     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
17181   };
17182 
17183   class Instance
17184   {
17185   public:
17186     using CType      = VkInstance;
17187     using NativeType = VkInstance;
17188 
17189     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
17190     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
17191       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
17192 
17193   public:
Instance()17194     Instance() VULKAN_HPP_NOEXCEPT{};  // = default - try to workaround a compiler issue
17195     Instance( Instance const & rhs )             = default;
17196     Instance & operator=( Instance const & rhs ) = default;
17197 
17198 #if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
17199     Instance( Instance && rhs )             = default;
17200     Instance & operator=( Instance && rhs ) = default;
17201 #else
Instance(Instance && rhs)17202     Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) {}
17203 
operator =(Instance && rhs)17204     Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT
17205     {
17206       m_instance = VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} );
17207       return *this;
17208     }
17209 #endif
17210 
Instance(std::nullptr_t)17211     VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
17212 
Instance(VkInstance instance)17213     Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
17214 
operator =(VkInstance instance)17215     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
17216     {
17217       m_instance = instance;
17218       return *this;
17219     }
17220 
operator =(std::nullptr_t)17221     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
17222     {
17223       m_instance = {};
17224       return *this;
17225     }
17226 
17227 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
17228     auto operator<=>( Instance const & ) const = default;
17229 #else
operator ==(Instance const & rhs) const17230     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
17231     {
17232       return m_instance == rhs.m_instance;
17233     }
17234 
operator !=(Instance const & rhs) const17235     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
17236     {
17237       return m_instance != rhs.m_instance;
17238     }
17239 
operator <(Instance const & rhs) const17240     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
17241     {
17242       return m_instance < rhs.m_instance;
17243     }
17244 #endif
17245 
17246     //=== VK_VERSION_1_0 ===
17247 
17248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17249     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17250                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17252     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17253     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17254                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17255 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17256 
17257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17258     VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
17259                                                           VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
17260                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17261 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17262     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17263     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
17264       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17265     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,
17266               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17267               typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>
17268     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type
17269       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17270 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17271 
17272     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17273     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17274 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17275     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17276     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17277 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17278 
17279     //=== VK_VERSION_1_1 ===
17280 
17281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17282     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t *                                            pPhysicalDeviceGroupCount,
17283                                                                VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
17284                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17286     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
17287               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17288     VULKAN_HPP_NODISCARD
17289       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
17290       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17291     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
17292               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17293               typename std::enable_if<
17294                 std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
17295                 int>::type = 0>
17296     VULKAN_HPP_NODISCARD
17297       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
17298       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
17299                                      Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17300 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17301 
17302     //=== VK_KHR_surface ===
17303 
17304     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17305     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
17306                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17307                             Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17308 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17309     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17310     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface                            VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
17311                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17312                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17313 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17314 
17315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17316     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
17317                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17318                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17319 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17320     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17321     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                                    surface,
17322                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17323                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17324 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17325 
17326     //=== VK_KHR_display ===
17327 
17328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17329     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
17330                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
17331                                                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
17332                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17333 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17334     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17335     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17336       createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,
17337                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17338                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17339 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
17340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17341     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17342       createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR &           createInfo,
17343                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17344                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17345 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
17346 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17347 
17348 #if defined( VK_USE_PLATFORM_XLIB_KHR )
17349     //=== VK_KHR_xlib_surface ===
17350 
17351     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17352     VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
17353                                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
17354                                                       VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
17355                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17356 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17357     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17358     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17359       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,
17360                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17361                             Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17362 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17363     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17364     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17365       createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR &              createInfo,
17366                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17367                                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17368 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17369 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17370 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/
17371 
17372 #if defined( VK_USE_PLATFORM_XCB_KHR )
17373     //=== VK_KHR_xcb_surface ===
17374 
17375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17376     VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
17377                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
17378                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
17379                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17380 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17382     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17383       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,
17384                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17385                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17386 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17388     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17389       createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR &               createInfo,
17390                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17391                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17392 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17393 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17394 #endif     /*VK_USE_PLATFORM_XCB_KHR*/
17395 
17396 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
17397     //=== VK_KHR_wayland_surface ===
17398 
17399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17400     VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
17401                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
17402                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
17403                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17404 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17406     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17407       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,
17408                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17409                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17410 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17412     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17413       createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR &           createInfo,
17414                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17415                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17416 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17417 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17418 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
17419 
17420 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
17421     //=== VK_KHR_android_surface ===
17422 
17423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17424     VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
17425                                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
17426                                                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
17427                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17428 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17429     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17430     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17431       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,
17432                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17433                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17434 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17436     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17437       createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR &           createInfo,
17438                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17439                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17440 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17441 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17442 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
17443 
17444 #if defined( VK_USE_PLATFORM_WIN32_KHR )
17445     //=== VK_KHR_win32_surface ===
17446 
17447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17448     VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
17449                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
17450                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
17451                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17452 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17453     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17454     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17455       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,
17456                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17457                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17458 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17459     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17460     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17461       createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR &             createInfo,
17462                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17463                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17464 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17465 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17466 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
17467 
17468     //=== VK_EXT_debug_report ===
17469 
17470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17471     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
17472                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
17473                                                               VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
17474                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17475 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17476     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17477     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
17478       createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,
17479                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17480                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17481 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
17482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17483     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
17484       createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT &      createInfo,
17485                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17486                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17487 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
17488 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17489 
17490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17491     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
17492                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17493                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17495     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17496     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback               VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
17497                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17498                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17499 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17500 
17501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17502     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
17503                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17504                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17507     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT                        callback,
17508                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17509                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17511 
17512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17513     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
17514                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
17515                                 uint64_t                                       object,
17516                                 size_t                                         location,
17517                                 int32_t                                        messageCode,
17518                                 const char *                                   pLayerPrefix,
17519                                 const char *                                   pMessage,
17520                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17523     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
17524                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
17525                                 uint64_t                                       object,
17526                                 size_t                                         location,
17527                                 int32_t                                        messageCode,
17528                                 const std::string &                            layerPrefix,
17529                                 const std::string &                            message,
17530                                 Dispatch const & d                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17531 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17532 
17533 #if defined( VK_USE_PLATFORM_GGP )
17534     //=== VK_GGP_stream_descriptor_surface ===
17535 
17536     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17537     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
17538                                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
17539                                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
17540                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17541 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17543     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17544       createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,
17545                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17546                                         Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17547 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17549     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique(
17550       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP &  createInfo,
17551       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17552       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17553 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17554 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17555 #endif     /*VK_USE_PLATFORM_GGP*/
17556 
17557 #if defined( VK_USE_PLATFORM_VI_NN )
17558     //=== VK_NN_vi_surface ===
17559 
17560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17561     VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
17562                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
17563                                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
17564                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17565 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17567     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17568       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,
17569                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17570                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17571 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17572     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17573     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17574       createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN &                 createInfo,
17575                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17576                                Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17577 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17578 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17579 #endif     /*VK_USE_PLATFORM_VI_NN*/
17580 
17581     //=== VK_KHR_device_group_creation ===
17582 
17583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17584     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t *                                            pPhysicalDeviceGroupCount,
17585                                                                   VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
17586                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17588     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
17589               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17590     VULKAN_HPP_NODISCARD
17591       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
17592       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17593     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
17594               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17595               typename std::enable_if<
17596                 std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
17597                 int>::type = 0>
17598     VULKAN_HPP_NODISCARD
17599       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
17600       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
17601                                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17602 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17603 
17604 #if defined( VK_USE_PLATFORM_IOS_MVK )
17605     //=== VK_MVK_ios_surface ===
17606 
17607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17608     VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
17609                                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
17610                                                      VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
17611                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17612 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17614     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17615       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,
17616                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17617                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17618 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17619     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17620     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17621       createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK &               createInfo,
17622                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17623                                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17624 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17625 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17626 #endif     /*VK_USE_PLATFORM_IOS_MVK*/
17627 
17628 #if defined( VK_USE_PLATFORM_MACOS_MVK )
17629     //=== VK_MVK_macos_surface ===
17630 
17631     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17632     VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
17633                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
17634                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
17635                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17636 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17638     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17639       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,
17640                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17641                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17642 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17644     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17645       createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK &             createInfo,
17646                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17647                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17648 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17649 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17650 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/
17651 
17652     //=== VK_EXT_debug_utils ===
17653 
17654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17655     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
17656                                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
17657                                                               VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
17658                                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17659 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17661     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
17662       createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,
17663                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17664                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17665 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
17666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17667     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
17668       createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT &      createInfo,
17669                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17670                                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17671 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
17672 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17673 
17674     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17675     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
17676                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17677                                         Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17679     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17680     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
17681                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17682                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17683 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17684 
17685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17686     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
17687                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17688                   Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17690     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17691     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT                        messenger,
17692                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17693                   Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17694 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17695 
17696     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17697     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
17698                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
17699                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
17700                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17703     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
17704                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
17705                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,
17706                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17707 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17708 
17709 #if defined( VK_USE_PLATFORM_FUCHSIA )
17710     //=== VK_FUCHSIA_imagepipe_surface ===
17711 
17712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17713     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
17714                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
17715                                                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
17716                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17717 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17719     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17720       createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,
17721                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17722                                      Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17723 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17725     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17726       createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA &     createInfo,
17727                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17728                                            Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17729 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17730 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17731 #endif     /*VK_USE_PLATFORM_FUCHSIA*/
17732 
17733 #if defined( VK_USE_PLATFORM_METAL_EXT )
17734     //=== VK_EXT_metal_surface ===
17735 
17736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17737     VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
17738                                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
17739                                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
17740                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17741 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17743     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17744       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,
17745                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17746                              Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17747 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17749     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17750       createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT &             createInfo,
17751                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17752                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17753 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17754 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17755 #endif     /*VK_USE_PLATFORM_METAL_EXT*/
17756 
17757     //=== VK_EXT_headless_surface ===
17758 
17759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17760     VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
17761                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
17762                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
17763                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17764 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17765     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17766     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17767       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,
17768                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17769                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17770 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
17771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17772     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17773       createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT &          createInfo,
17774                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17775                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17776 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
17777 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17778 
17779 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
17780     //=== VK_EXT_directfb_surface ===
17781 
17782     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17783     VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
17784                                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
17785                                                           VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
17786                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17787 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17789     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17790       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,
17791                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17792                                 Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17793 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17795     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17796       createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT &          createInfo,
17797                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17798                                       Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17799 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17800 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17801 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
17802 
17803 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
17804     //=== VK_QNX_screen_surface ===
17805 
17806     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17807     VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
17808                                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
17809                                                         VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
17810                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
17811 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17812     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17813     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
17814       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,
17815                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17816                               Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17817 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
17818     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17819     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
17820       createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX &            createInfo,
17821                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17822                                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
17823 #    endif /* VULKAN_HPP_NO_SMART_HANDLE */
17824 #  endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17825 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
17826 
operator VkInstance() const17827     operator VkInstance() const VULKAN_HPP_NOEXCEPT
17828     {
17829       return m_instance;
17830     }
17831 
operator bool() const17832     explicit operator bool() const VULKAN_HPP_NOEXCEPT
17833     {
17834       return m_instance != VK_NULL_HANDLE;
17835     }
17836 
operator !() const17837     bool operator!() const VULKAN_HPP_NOEXCEPT
17838     {
17839       return m_instance == VK_NULL_HANDLE;
17840     }
17841 
17842   private:
17843     VkInstance m_instance = {};
17844   };
17845 
17846   template <>
17847   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
17848   {
17849     using Type = VULKAN_HPP_NAMESPACE::Instance;
17850   };
17851 
17852   template <>
17853   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
17854   {
17855     using Type = VULKAN_HPP_NAMESPACE::Instance;
17856   };
17857 
17858 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
17859   template <>
17860   struct CppType<VkInstance, VK_NULL_HANDLE>
17861   {
17862     using Type = VULKAN_HPP_NAMESPACE::Instance;
17863   };
17864 #endif
17865 
17866   template <>
17867   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
17868   {
17869     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
17870   };
17871 
17872   //=== VK_VERSION_1_0 ===
17873 
17874   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17875   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
17876                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
17877                                               VULKAN_HPP_NAMESPACE::Instance *                  pInstance,
17878                                               Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
17879 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17880   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17881   VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type
17882     createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
17883                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17884                     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17885 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
17886   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17887   VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
17888     createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
17889                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17890                           Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17891 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
17892 #endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17893 
17894   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17895   VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char *                                pLayerName,
17896                                                                     uint32_t *                                  pPropertyCount,
17897                                                                     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
17898                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
17899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17900   template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
17901             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17902   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
17903     enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
17904                                           Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17905   template <
17906     typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
17907     typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17908     typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
17909   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type
17910     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
17911                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
17912                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17914 
17915   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17916   VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
17917                                                                 VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
17918                                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
17919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17920   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17921   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
17922     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17923   template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
17924             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
17925             typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
17926   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type
17927     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17928 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17929 
17930   //=== VK_VERSION_1_1 ===
17931 
17932   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17933   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t *         pApiVersion,
17934                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
17935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
17936   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
17937   VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
17938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
17939 
17940 }  // namespace VULKAN_HPP_NAMESPACE
17941 
17942 // operators to compare vk::-handles with nullptr
17943 template <typename T>
operator ==(const T & v,std::nullptr_t)17944 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
17945 {
17946   return !v;
17947 }
17948 
17949 template <typename T>
operator ==(std::nullptr_t,const T & v)17950 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
17951 {
17952   return !v;
17953 }
17954 
17955 template <typename T>
operator !=(const T & v,std::nullptr_t)17956 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
17957 {
17958   return v;
17959 }
17960 
17961 template <typename T>
operator !=(std::nullptr_t,const T & v)17962 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )
17963 {
17964   return v;
17965 }
17966 #endif
17967