• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2015-2021 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HANDLES_HPP
9 #define VULKAN_HANDLES_HPP
10 
11 namespace VULKAN_HPP_NAMESPACE
12 {
13   //===================================
14   //=== STRUCT forward declarations ===
15   //===================================
16 
17   //=== VK_VERSION_1_0 ===
18   struct Extent2D;
19   struct Extent3D;
20   struct Offset2D;
21   struct Offset3D;
22   struct Rect2D;
23   struct BaseInStructure;
24   struct BaseOutStructure;
25   struct BufferMemoryBarrier;
26   struct DispatchIndirectCommand;
27   struct DrawIndexedIndirectCommand;
28   struct DrawIndirectCommand;
29   struct ImageMemoryBarrier;
30   struct MemoryBarrier;
31   struct PipelineCacheHeaderVersionOne;
32   struct AllocationCallbacks;
33   struct ApplicationInfo;
34   struct FormatProperties;
35   struct ImageFormatProperties;
36   struct InstanceCreateInfo;
37   struct MemoryHeap;
38   struct MemoryType;
39   struct PhysicalDeviceFeatures;
40   struct PhysicalDeviceLimits;
41   struct PhysicalDeviceMemoryProperties;
42   struct PhysicalDeviceProperties;
43   struct PhysicalDeviceSparseProperties;
44   struct QueueFamilyProperties;
45   struct DeviceCreateInfo;
46   struct DeviceQueueCreateInfo;
47   struct ExtensionProperties;
48   struct LayerProperties;
49   struct SubmitInfo;
50   struct MappedMemoryRange;
51   struct MemoryAllocateInfo;
52   struct MemoryRequirements;
53   struct BindSparseInfo;
54   struct ImageSubresource;
55   struct SparseBufferMemoryBindInfo;
56   struct SparseImageFormatProperties;
57   struct SparseImageMemoryBind;
58   struct SparseImageMemoryBindInfo;
59   struct SparseImageMemoryRequirements;
60   struct SparseImageOpaqueMemoryBindInfo;
61   struct SparseMemoryBind;
62   struct FenceCreateInfo;
63   struct SemaphoreCreateInfo;
64   struct EventCreateInfo;
65   struct QueryPoolCreateInfo;
66   struct BufferCreateInfo;
67   struct BufferViewCreateInfo;
68   struct ImageCreateInfo;
69   struct SubresourceLayout;
70   struct ComponentMapping;
71   struct ImageSubresourceRange;
72   struct ImageViewCreateInfo;
73   struct ShaderModuleCreateInfo;
74   struct PipelineCacheCreateInfo;
75   struct ComputePipelineCreateInfo;
76   struct GraphicsPipelineCreateInfo;
77   struct PipelineColorBlendAttachmentState;
78   struct PipelineColorBlendStateCreateInfo;
79   struct PipelineDepthStencilStateCreateInfo;
80   struct PipelineDynamicStateCreateInfo;
81   struct PipelineInputAssemblyStateCreateInfo;
82   struct PipelineMultisampleStateCreateInfo;
83   struct PipelineRasterizationStateCreateInfo;
84   struct PipelineShaderStageCreateInfo;
85   struct PipelineTessellationStateCreateInfo;
86   struct PipelineVertexInputStateCreateInfo;
87   struct PipelineViewportStateCreateInfo;
88   struct SpecializationInfo;
89   struct SpecializationMapEntry;
90   struct StencilOpState;
91   struct VertexInputAttributeDescription;
92   struct VertexInputBindingDescription;
93   struct Viewport;
94   struct PipelineLayoutCreateInfo;
95   struct PushConstantRange;
96   struct SamplerCreateInfo;
97   struct CopyDescriptorSet;
98   struct DescriptorBufferInfo;
99   struct DescriptorImageInfo;
100   struct DescriptorPoolCreateInfo;
101   struct DescriptorPoolSize;
102   struct DescriptorSetAllocateInfo;
103   struct DescriptorSetLayoutBinding;
104   struct DescriptorSetLayoutCreateInfo;
105   struct WriteDescriptorSet;
106   struct AttachmentDescription;
107   struct AttachmentReference;
108   struct FramebufferCreateInfo;
109   struct RenderPassCreateInfo;
110   struct SubpassDependency;
111   struct SubpassDescription;
112   struct CommandPoolCreateInfo;
113   struct CommandBufferAllocateInfo;
114   struct CommandBufferBeginInfo;
115   struct CommandBufferInheritanceInfo;
116   struct BufferCopy;
117   struct BufferImageCopy;
118   struct ClearAttachment;
119   union ClearColorValue;
120   struct ClearDepthStencilValue;
121   struct ClearRect;
122   union ClearValue;
123   struct ImageBlit;
124   struct ImageCopy;
125   struct ImageResolve;
126   struct ImageSubresourceLayers;
127   struct RenderPassBeginInfo;
128 
129   //=== VK_VERSION_1_1 ===
130   struct PhysicalDeviceSubgroupProperties;
131   struct BindBufferMemoryInfo;
132   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
133   struct BindImageMemoryInfo;
134   using BindImageMemoryInfoKHR = BindImageMemoryInfo;
135   struct PhysicalDevice16BitStorageFeatures;
136   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
137   struct MemoryDedicatedRequirements;
138   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
139   struct MemoryDedicatedAllocateInfo;
140   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
141   struct MemoryAllocateFlagsInfo;
142   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
143   struct DeviceGroupRenderPassBeginInfo;
144   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
145   struct DeviceGroupCommandBufferBeginInfo;
146   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
147   struct DeviceGroupSubmitInfo;
148   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
149   struct DeviceGroupBindSparseInfo;
150   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
151   struct BindBufferMemoryDeviceGroupInfo;
152   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
153   struct BindImageMemoryDeviceGroupInfo;
154   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
155   struct PhysicalDeviceGroupProperties;
156   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
157   struct DeviceGroupDeviceCreateInfo;
158   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
159   struct BufferMemoryRequirementsInfo2;
160   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
161   struct ImageMemoryRequirementsInfo2;
162   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
163   struct ImageSparseMemoryRequirementsInfo2;
164   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
165   struct MemoryRequirements2;
166   using MemoryRequirements2KHR = MemoryRequirements2;
167   struct SparseImageMemoryRequirements2;
168   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
169   struct PhysicalDeviceFeatures2;
170   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
171   struct PhysicalDeviceProperties2;
172   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
173   struct FormatProperties2;
174   using FormatProperties2KHR = FormatProperties2;
175   struct ImageFormatProperties2;
176   using ImageFormatProperties2KHR = ImageFormatProperties2;
177   struct PhysicalDeviceImageFormatInfo2;
178   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
179   struct QueueFamilyProperties2;
180   using QueueFamilyProperties2KHR = QueueFamilyProperties2;
181   struct PhysicalDeviceMemoryProperties2;
182   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
183   struct SparseImageFormatProperties2;
184   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
185   struct PhysicalDeviceSparseImageFormatInfo2;
186   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
187   struct PhysicalDevicePointClippingProperties;
188   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
189   struct RenderPassInputAttachmentAspectCreateInfo;
190   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
191   struct InputAttachmentAspectReference;
192   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
193   struct ImageViewUsageCreateInfo;
194   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
195   struct PipelineTessellationDomainOriginStateCreateInfo;
196   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
197   struct RenderPassMultiviewCreateInfo;
198   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
199   struct PhysicalDeviceMultiviewFeatures;
200   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
201   struct PhysicalDeviceMultiviewProperties;
202   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
203   struct PhysicalDeviceVariablePointersFeatures;
204   using PhysicalDeviceVariablePointerFeatures     = PhysicalDeviceVariablePointersFeatures;
205   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;
206   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
207   struct PhysicalDeviceProtectedMemoryFeatures;
208   struct PhysicalDeviceProtectedMemoryProperties;
209   struct DeviceQueueInfo2;
210   struct ProtectedSubmitInfo;
211   struct SamplerYcbcrConversionCreateInfo;
212   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
213   struct SamplerYcbcrConversionInfo;
214   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
215   struct BindImagePlaneMemoryInfo;
216   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
217   struct ImagePlaneMemoryRequirementsInfo;
218   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
219   struct PhysicalDeviceSamplerYcbcrConversionFeatures;
220   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
221   struct SamplerYcbcrConversionImageFormatProperties;
222   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
223   struct DescriptorUpdateTemplateEntry;
224   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
225   struct DescriptorUpdateTemplateCreateInfo;
226   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
227   struct ExternalMemoryProperties;
228   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
229   struct PhysicalDeviceExternalImageFormatInfo;
230   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
231   struct ExternalImageFormatProperties;
232   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
233   struct PhysicalDeviceExternalBufferInfo;
234   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
235   struct ExternalBufferProperties;
236   using ExternalBufferPropertiesKHR = ExternalBufferProperties;
237   struct PhysicalDeviceIDProperties;
238   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
239   struct ExternalMemoryImageCreateInfo;
240   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
241   struct ExternalMemoryBufferCreateInfo;
242   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
243   struct ExportMemoryAllocateInfo;
244   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
245   struct PhysicalDeviceExternalFenceInfo;
246   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
247   struct ExternalFenceProperties;
248   using ExternalFencePropertiesKHR = ExternalFenceProperties;
249   struct ExportFenceCreateInfo;
250   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
251   struct ExportSemaphoreCreateInfo;
252   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
253   struct PhysicalDeviceExternalSemaphoreInfo;
254   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
255   struct ExternalSemaphoreProperties;
256   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
257   struct PhysicalDeviceMaintenance3Properties;
258   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
259   struct DescriptorSetLayoutSupport;
260   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
261   struct PhysicalDeviceShaderDrawParametersFeatures;
262   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
263 
264   //=== VK_VERSION_1_2 ===
265   struct PhysicalDeviceVulkan11Features;
266   struct PhysicalDeviceVulkan11Properties;
267   struct PhysicalDeviceVulkan12Features;
268   struct PhysicalDeviceVulkan12Properties;
269   struct ImageFormatListCreateInfo;
270   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
271   struct RenderPassCreateInfo2;
272   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
273   struct AttachmentDescription2;
274   using AttachmentDescription2KHR = AttachmentDescription2;
275   struct AttachmentReference2;
276   using AttachmentReference2KHR = AttachmentReference2;
277   struct SubpassDescription2;
278   using SubpassDescription2KHR = SubpassDescription2;
279   struct SubpassDependency2;
280   using SubpassDependency2KHR = SubpassDependency2;
281   struct SubpassBeginInfo;
282   using SubpassBeginInfoKHR = SubpassBeginInfo;
283   struct SubpassEndInfo;
284   using SubpassEndInfoKHR = SubpassEndInfo;
285   struct PhysicalDevice8BitStorageFeatures;
286   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
287   struct ConformanceVersion;
288   using ConformanceVersionKHR = ConformanceVersion;
289   struct PhysicalDeviceDriverProperties;
290   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
291   struct PhysicalDeviceShaderAtomicInt64Features;
292   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
293   struct PhysicalDeviceShaderFloat16Int8Features;
294   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
295   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
296   struct PhysicalDeviceFloatControlsProperties;
297   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
298   struct DescriptorSetLayoutBindingFlagsCreateInfo;
299   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
300   struct PhysicalDeviceDescriptorIndexingFeatures;
301   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
302   struct PhysicalDeviceDescriptorIndexingProperties;
303   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
304   struct DescriptorSetVariableDescriptorCountAllocateInfo;
305   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
306   struct DescriptorSetVariableDescriptorCountLayoutSupport;
307   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
308   struct SubpassDescriptionDepthStencilResolve;
309   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
310   struct PhysicalDeviceDepthStencilResolveProperties;
311   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
312   struct PhysicalDeviceScalarBlockLayoutFeatures;
313   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
314   struct ImageStencilUsageCreateInfo;
315   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
316   struct SamplerReductionModeCreateInfo;
317   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
318   struct PhysicalDeviceSamplerFilterMinmaxProperties;
319   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
320   struct PhysicalDeviceVulkanMemoryModelFeatures;
321   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
322   struct PhysicalDeviceImagelessFramebufferFeatures;
323   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
324   struct FramebufferAttachmentsCreateInfo;
325   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
326   struct FramebufferAttachmentImageInfo;
327   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
328   struct RenderPassAttachmentBeginInfo;
329   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
330   struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
331   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
332   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
333   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
334   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
335   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
336   struct AttachmentReferenceStencilLayout;
337   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
338   struct AttachmentDescriptionStencilLayout;
339   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
340   struct PhysicalDeviceHostQueryResetFeatures;
341   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
342   struct PhysicalDeviceTimelineSemaphoreFeatures;
343   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
344   struct PhysicalDeviceTimelineSemaphoreProperties;
345   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
346   struct SemaphoreTypeCreateInfo;
347   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
348   struct TimelineSemaphoreSubmitInfo;
349   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
350   struct SemaphoreWaitInfo;
351   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
352   struct SemaphoreSignalInfo;
353   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
354   struct PhysicalDeviceBufferDeviceAddressFeatures;
355   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
356   struct BufferDeviceAddressInfo;
357   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
358   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
359   struct BufferOpaqueCaptureAddressCreateInfo;
360   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
361   struct MemoryOpaqueCaptureAddressAllocateInfo;
362   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
363   struct DeviceMemoryOpaqueCaptureAddressInfo;
364   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
365 
366   //=== VK_KHR_surface ===
367   struct SurfaceCapabilitiesKHR;
368   struct SurfaceFormatKHR;
369 
370   //=== VK_KHR_swapchain ===
371   struct SwapchainCreateInfoKHR;
372   struct PresentInfoKHR;
373   struct ImageSwapchainCreateInfoKHR;
374   struct BindImageMemorySwapchainInfoKHR;
375   struct AcquireNextImageInfoKHR;
376   struct DeviceGroupPresentCapabilitiesKHR;
377   struct DeviceGroupPresentInfoKHR;
378   struct DeviceGroupSwapchainCreateInfoKHR;
379 
380   //=== VK_KHR_display ===
381   struct DisplayModeCreateInfoKHR;
382   struct DisplayModeParametersKHR;
383   struct DisplayModePropertiesKHR;
384   struct DisplayPlaneCapabilitiesKHR;
385   struct DisplayPlanePropertiesKHR;
386   struct DisplayPropertiesKHR;
387   struct DisplaySurfaceCreateInfoKHR;
388 
389   //=== VK_KHR_display_swapchain ===
390   struct DisplayPresentInfoKHR;
391 
392 #if defined( VK_USE_PLATFORM_XLIB_KHR )
393   //=== VK_KHR_xlib_surface ===
394   struct XlibSurfaceCreateInfoKHR;
395 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
396 
397 #if defined( VK_USE_PLATFORM_XCB_KHR )
398   //=== VK_KHR_xcb_surface ===
399   struct XcbSurfaceCreateInfoKHR;
400 #endif /*VK_USE_PLATFORM_XCB_KHR*/
401 
402 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
403   //=== VK_KHR_wayland_surface ===
404   struct WaylandSurfaceCreateInfoKHR;
405 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
406 
407 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
408   //=== VK_KHR_android_surface ===
409   struct AndroidSurfaceCreateInfoKHR;
410 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
411 
412 #if defined( VK_USE_PLATFORM_WIN32_KHR )
413   //=== VK_KHR_win32_surface ===
414   struct Win32SurfaceCreateInfoKHR;
415 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
416 
417   //=== VK_EXT_debug_report ===
418   struct DebugReportCallbackCreateInfoEXT;
419 
420   //=== VK_AMD_rasterization_order ===
421   struct PipelineRasterizationStateRasterizationOrderAMD;
422 
423   //=== VK_EXT_debug_marker ===
424   struct DebugMarkerObjectNameInfoEXT;
425   struct DebugMarkerObjectTagInfoEXT;
426   struct DebugMarkerMarkerInfoEXT;
427 
428 #if defined( VK_ENABLE_BETA_EXTENSIONS )
429   //=== VK_KHR_video_queue ===
430   struct VideoQueueFamilyProperties2KHR;
431   struct VideoProfileKHR;
432   struct VideoProfilesKHR;
433   struct VideoCapabilitiesKHR;
434   struct PhysicalDeviceVideoFormatInfoKHR;
435   struct VideoFormatPropertiesKHR;
436   struct VideoPictureResourceKHR;
437   struct VideoReferenceSlotKHR;
438   struct VideoGetMemoryPropertiesKHR;
439   struct VideoBindMemoryKHR;
440   struct VideoSessionCreateInfoKHR;
441   struct VideoSessionParametersCreateInfoKHR;
442   struct VideoSessionParametersUpdateInfoKHR;
443   struct VideoBeginCodingInfoKHR;
444   struct VideoEndCodingInfoKHR;
445   struct VideoCodingControlInfoKHR;
446 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
447 
448 #if defined( VK_ENABLE_BETA_EXTENSIONS )
449   //=== VK_KHR_video_decode_queue ===
450   struct VideoDecodeInfoKHR;
451 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
452 
453   //=== VK_NV_dedicated_allocation ===
454   struct DedicatedAllocationImageCreateInfoNV;
455   struct DedicatedAllocationBufferCreateInfoNV;
456   struct DedicatedAllocationMemoryAllocateInfoNV;
457 
458   //=== VK_EXT_transform_feedback ===
459   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
460   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
461   struct PipelineRasterizationStateStreamCreateInfoEXT;
462 
463   //=== VK_NVX_binary_import ===
464   struct CuModuleCreateInfoNVX;
465   struct CuFunctionCreateInfoNVX;
466   struct CuLaunchInfoNVX;
467 
468   //=== VK_NVX_image_view_handle ===
469   struct ImageViewHandleInfoNVX;
470   struct ImageViewAddressPropertiesNVX;
471 
472 #if defined( VK_ENABLE_BETA_EXTENSIONS )
473   //=== VK_EXT_video_encode_h264 ===
474   struct VideoEncodeH264CapabilitiesEXT;
475   struct VideoEncodeH264SessionCreateInfoEXT;
476   struct VideoEncodeH264SessionParametersCreateInfoEXT;
477   struct VideoEncodeH264SessionParametersAddInfoEXT;
478   struct VideoEncodeH264VclFrameInfoEXT;
479   struct VideoEncodeH264EmitPictureParametersEXT;
480   struct VideoEncodeH264DpbSlotInfoEXT;
481   struct VideoEncodeH264NaluSliceEXT;
482   struct VideoEncodeH264ProfileEXT;
483 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
484 
485 #if defined( VK_ENABLE_BETA_EXTENSIONS )
486   //=== VK_EXT_video_encode_h265 ===
487   struct VideoEncodeH265CapabilitiesEXT;
488   struct VideoEncodeH265SessionCreateInfoEXT;
489   struct VideoEncodeH265SessionParametersCreateInfoEXT;
490   struct VideoEncodeH265SessionParametersAddInfoEXT;
491   struct VideoEncodeH265VclFrameInfoEXT;
492   struct VideoEncodeH265EmitPictureParametersEXT;
493   struct VideoEncodeH265DpbSlotInfoEXT;
494   struct VideoEncodeH265NaluSliceEXT;
495   struct VideoEncodeH265ProfileEXT;
496   struct VideoEncodeH265ReferenceListsEXT;
497 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
498 
499 #if defined( VK_ENABLE_BETA_EXTENSIONS )
500   //=== VK_EXT_video_decode_h264 ===
501   struct VideoDecodeH264ProfileEXT;
502   struct VideoDecodeH264CapabilitiesEXT;
503   struct VideoDecodeH264SessionCreateInfoEXT;
504   struct VideoDecodeH264SessionParametersCreateInfoEXT;
505   struct VideoDecodeH264SessionParametersAddInfoEXT;
506   struct VideoDecodeH264PictureInfoEXT;
507   struct VideoDecodeH264MvcEXT;
508   struct VideoDecodeH264DpbSlotInfoEXT;
509 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
510 
511   //=== VK_AMD_texture_gather_bias_lod ===
512   struct TextureLODGatherFormatPropertiesAMD;
513 
514   //=== VK_AMD_shader_info ===
515   struct ShaderResourceUsageAMD;
516   struct ShaderStatisticsInfoAMD;
517 
518 #if defined( VK_USE_PLATFORM_GGP )
519   //=== VK_GGP_stream_descriptor_surface ===
520   struct StreamDescriptorSurfaceCreateInfoGGP;
521 #endif /*VK_USE_PLATFORM_GGP*/
522 
523   //=== VK_NV_corner_sampled_image ===
524   struct PhysicalDeviceCornerSampledImageFeaturesNV;
525 
526   //=== VK_NV_external_memory_capabilities ===
527   struct ExternalImageFormatPropertiesNV;
528 
529   //=== VK_NV_external_memory ===
530   struct ExternalMemoryImageCreateInfoNV;
531   struct ExportMemoryAllocateInfoNV;
532 
533 #if defined( VK_USE_PLATFORM_WIN32_KHR )
534   //=== VK_NV_external_memory_win32 ===
535   struct ImportMemoryWin32HandleInfoNV;
536   struct ExportMemoryWin32HandleInfoNV;
537 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
538 
539 #if defined( VK_USE_PLATFORM_WIN32_KHR )
540   //=== VK_NV_win32_keyed_mutex ===
541   struct Win32KeyedMutexAcquireReleaseInfoNV;
542 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
543 
544   //=== VK_EXT_validation_flags ===
545   struct ValidationFlagsEXT;
546 
547 #if defined( VK_USE_PLATFORM_VI_NN )
548   //=== VK_NN_vi_surface ===
549   struct ViSurfaceCreateInfoNN;
550 #endif /*VK_USE_PLATFORM_VI_NN*/
551 
552   //=== VK_EXT_texture_compression_astc_hdr ===
553   struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
554 
555   //=== VK_EXT_astc_decode_mode ===
556   struct ImageViewASTCDecodeModeEXT;
557   struct PhysicalDeviceASTCDecodeFeaturesEXT;
558 
559 #if defined( VK_USE_PLATFORM_WIN32_KHR )
560   //=== VK_KHR_external_memory_win32 ===
561   struct ImportMemoryWin32HandleInfoKHR;
562   struct ExportMemoryWin32HandleInfoKHR;
563   struct MemoryWin32HandlePropertiesKHR;
564   struct MemoryGetWin32HandleInfoKHR;
565 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
566 
567   //=== VK_KHR_external_memory_fd ===
568   struct ImportMemoryFdInfoKHR;
569   struct MemoryFdPropertiesKHR;
570   struct MemoryGetFdInfoKHR;
571 
572 #if defined( VK_USE_PLATFORM_WIN32_KHR )
573   //=== VK_KHR_win32_keyed_mutex ===
574   struct Win32KeyedMutexAcquireReleaseInfoKHR;
575 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
576 
577 #if defined( VK_USE_PLATFORM_WIN32_KHR )
578   //=== VK_KHR_external_semaphore_win32 ===
579   struct ImportSemaphoreWin32HandleInfoKHR;
580   struct ExportSemaphoreWin32HandleInfoKHR;
581   struct D3D12FenceSubmitInfoKHR;
582   struct SemaphoreGetWin32HandleInfoKHR;
583 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
584 
585   //=== VK_KHR_external_semaphore_fd ===
586   struct ImportSemaphoreFdInfoKHR;
587   struct SemaphoreGetFdInfoKHR;
588 
589   //=== VK_KHR_push_descriptor ===
590   struct PhysicalDevicePushDescriptorPropertiesKHR;
591 
592   //=== VK_EXT_conditional_rendering ===
593   struct ConditionalRenderingBeginInfoEXT;
594   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
595   struct CommandBufferInheritanceConditionalRenderingInfoEXT;
596 
597   //=== VK_KHR_incremental_present ===
598   struct PresentRegionsKHR;
599   struct PresentRegionKHR;
600   struct RectLayerKHR;
601 
602   //=== VK_NV_clip_space_w_scaling ===
603   struct ViewportWScalingNV;
604   struct PipelineViewportWScalingStateCreateInfoNV;
605 
606   //=== VK_EXT_display_surface_counter ===
607   struct SurfaceCapabilities2EXT;
608 
609   //=== VK_EXT_display_control ===
610   struct DisplayPowerInfoEXT;
611   struct DeviceEventInfoEXT;
612   struct DisplayEventInfoEXT;
613   struct SwapchainCounterCreateInfoEXT;
614 
615   //=== VK_GOOGLE_display_timing ===
616   struct RefreshCycleDurationGOOGLE;
617   struct PastPresentationTimingGOOGLE;
618   struct PresentTimesInfoGOOGLE;
619   struct PresentTimeGOOGLE;
620 
621   //=== VK_NVX_multiview_per_view_attributes ===
622   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
623 
624   //=== VK_NV_viewport_swizzle ===
625   struct ViewportSwizzleNV;
626   struct PipelineViewportSwizzleStateCreateInfoNV;
627 
628   //=== VK_EXT_discard_rectangles ===
629   struct PhysicalDeviceDiscardRectanglePropertiesEXT;
630   struct PipelineDiscardRectangleStateCreateInfoEXT;
631 
632   //=== VK_EXT_conservative_rasterization ===
633   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
634   struct PipelineRasterizationConservativeStateCreateInfoEXT;
635 
636   //=== VK_EXT_depth_clip_enable ===
637   struct PhysicalDeviceDepthClipEnableFeaturesEXT;
638   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
639 
640   //=== VK_EXT_hdr_metadata ===
641   struct HdrMetadataEXT;
642   struct XYColorEXT;
643 
644   //=== VK_KHR_shared_presentable_image ===
645   struct SharedPresentSurfaceCapabilitiesKHR;
646 
647 #if defined( VK_USE_PLATFORM_WIN32_KHR )
648   //=== VK_KHR_external_fence_win32 ===
649   struct ImportFenceWin32HandleInfoKHR;
650   struct ExportFenceWin32HandleInfoKHR;
651   struct FenceGetWin32HandleInfoKHR;
652 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
653 
654   //=== VK_KHR_external_fence_fd ===
655   struct ImportFenceFdInfoKHR;
656   struct FenceGetFdInfoKHR;
657 
658   //=== VK_KHR_performance_query ===
659   struct PhysicalDevicePerformanceQueryFeaturesKHR;
660   struct PhysicalDevicePerformanceQueryPropertiesKHR;
661   struct PerformanceCounterKHR;
662   struct PerformanceCounterDescriptionKHR;
663   struct QueryPoolPerformanceCreateInfoKHR;
664   union PerformanceCounterResultKHR;
665   struct AcquireProfilingLockInfoKHR;
666   struct PerformanceQuerySubmitInfoKHR;
667 
668   //=== VK_KHR_get_surface_capabilities2 ===
669   struct PhysicalDeviceSurfaceInfo2KHR;
670   struct SurfaceCapabilities2KHR;
671   struct SurfaceFormat2KHR;
672 
673   //=== VK_KHR_get_display_properties2 ===
674   struct DisplayProperties2KHR;
675   struct DisplayPlaneProperties2KHR;
676   struct DisplayModeProperties2KHR;
677   struct DisplayPlaneInfo2KHR;
678   struct DisplayPlaneCapabilities2KHR;
679 
680 #if defined( VK_USE_PLATFORM_IOS_MVK )
681   //=== VK_MVK_ios_surface ===
682   struct IOSSurfaceCreateInfoMVK;
683 #endif /*VK_USE_PLATFORM_IOS_MVK*/
684 
685 #if defined( VK_USE_PLATFORM_MACOS_MVK )
686   //=== VK_MVK_macos_surface ===
687   struct MacOSSurfaceCreateInfoMVK;
688 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
689 
690   //=== VK_EXT_debug_utils ===
691   struct DebugUtilsLabelEXT;
692   struct DebugUtilsMessengerCallbackDataEXT;
693   struct DebugUtilsMessengerCreateInfoEXT;
694   struct DebugUtilsObjectNameInfoEXT;
695   struct DebugUtilsObjectTagInfoEXT;
696 
697 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
698   //=== VK_ANDROID_external_memory_android_hardware_buffer ===
699   struct AndroidHardwareBufferUsageANDROID;
700   struct AndroidHardwareBufferPropertiesANDROID;
701   struct AndroidHardwareBufferFormatPropertiesANDROID;
702   struct ImportAndroidHardwareBufferInfoANDROID;
703   struct MemoryGetAndroidHardwareBufferInfoANDROID;
704   struct ExternalFormatANDROID;
705   struct AndroidHardwareBufferFormatProperties2ANDROID;
706 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
707 
708   //=== VK_EXT_inline_uniform_block ===
709   struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
710   struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
711   struct WriteDescriptorSetInlineUniformBlockEXT;
712   struct DescriptorPoolInlineUniformBlockCreateInfoEXT;
713 
714   //=== VK_EXT_sample_locations ===
715   struct SampleLocationEXT;
716   struct SampleLocationsInfoEXT;
717   struct AttachmentSampleLocationsEXT;
718   struct SubpassSampleLocationsEXT;
719   struct RenderPassSampleLocationsBeginInfoEXT;
720   struct PipelineSampleLocationsStateCreateInfoEXT;
721   struct PhysicalDeviceSampleLocationsPropertiesEXT;
722   struct MultisamplePropertiesEXT;
723 
724   //=== VK_EXT_blend_operation_advanced ===
725   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
726   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
727   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
728 
729   //=== VK_NV_fragment_coverage_to_color ===
730   struct PipelineCoverageToColorStateCreateInfoNV;
731 
732   //=== VK_KHR_acceleration_structure ===
733   union DeviceOrHostAddressKHR;
734   union DeviceOrHostAddressConstKHR;
735   struct AccelerationStructureBuildRangeInfoKHR;
736   struct AabbPositionsKHR;
737   using AabbPositionsNV = AabbPositionsKHR;
738   struct AccelerationStructureGeometryTrianglesDataKHR;
739   struct TransformMatrixKHR;
740   using TransformMatrixNV = TransformMatrixKHR;
741   struct AccelerationStructureBuildGeometryInfoKHR;
742   struct AccelerationStructureGeometryAabbsDataKHR;
743   struct AccelerationStructureInstanceKHR;
744   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
745   struct AccelerationStructureGeometryInstancesDataKHR;
746   union AccelerationStructureGeometryDataKHR;
747   struct AccelerationStructureGeometryKHR;
748   struct AccelerationStructureCreateInfoKHR;
749   struct WriteDescriptorSetAccelerationStructureKHR;
750   struct PhysicalDeviceAccelerationStructureFeaturesKHR;
751   struct PhysicalDeviceAccelerationStructurePropertiesKHR;
752   struct AccelerationStructureDeviceAddressInfoKHR;
753   struct AccelerationStructureVersionInfoKHR;
754   struct CopyAccelerationStructureToMemoryInfoKHR;
755   struct CopyMemoryToAccelerationStructureInfoKHR;
756   struct CopyAccelerationStructureInfoKHR;
757   struct AccelerationStructureBuildSizesInfoKHR;
758 
759   //=== VK_NV_framebuffer_mixed_samples ===
760   struct PipelineCoverageModulationStateCreateInfoNV;
761 
762   //=== VK_NV_shader_sm_builtins ===
763   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
764   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
765 
766   //=== VK_EXT_image_drm_format_modifier ===
767   struct DrmFormatModifierPropertiesListEXT;
768   struct DrmFormatModifierPropertiesEXT;
769   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
770   struct ImageDrmFormatModifierListCreateInfoEXT;
771   struct ImageDrmFormatModifierExplicitCreateInfoEXT;
772   struct ImageDrmFormatModifierPropertiesEXT;
773   struct DrmFormatModifierPropertiesList2EXT;
774   struct DrmFormatModifierProperties2EXT;
775 
776   //=== VK_EXT_validation_cache ===
777   struct ValidationCacheCreateInfoEXT;
778   struct ShaderModuleValidationCacheCreateInfoEXT;
779 
780 #if defined( VK_ENABLE_BETA_EXTENSIONS )
781   //=== VK_KHR_portability_subset ===
782   struct PhysicalDevicePortabilitySubsetFeaturesKHR;
783   struct PhysicalDevicePortabilitySubsetPropertiesKHR;
784 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
785 
786   //=== VK_NV_shading_rate_image ===
787   struct ShadingRatePaletteNV;
788   struct PipelineViewportShadingRateImageStateCreateInfoNV;
789   struct PhysicalDeviceShadingRateImageFeaturesNV;
790   struct PhysicalDeviceShadingRateImagePropertiesNV;
791   struct CoarseSampleLocationNV;
792   struct CoarseSampleOrderCustomNV;
793   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
794 
795   //=== VK_NV_ray_tracing ===
796   struct RayTracingShaderGroupCreateInfoNV;
797   struct RayTracingPipelineCreateInfoNV;
798   struct GeometryTrianglesNV;
799   struct GeometryAABBNV;
800   struct GeometryDataNV;
801   struct GeometryNV;
802   struct AccelerationStructureInfoNV;
803   struct AccelerationStructureCreateInfoNV;
804   struct BindAccelerationStructureMemoryInfoNV;
805   struct WriteDescriptorSetAccelerationStructureNV;
806   struct AccelerationStructureMemoryRequirementsInfoNV;
807   struct PhysicalDeviceRayTracingPropertiesNV;
808 
809   //=== VK_NV_representative_fragment_test ===
810   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
811   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
812 
813   //=== VK_EXT_filter_cubic ===
814   struct PhysicalDeviceImageViewImageFormatInfoEXT;
815   struct FilterCubicImageViewImageFormatPropertiesEXT;
816 
817   //=== VK_EXT_global_priority ===
818   struct DeviceQueueGlobalPriorityCreateInfoEXT;
819 
820   //=== VK_EXT_external_memory_host ===
821   struct ImportMemoryHostPointerInfoEXT;
822   struct MemoryHostPointerPropertiesEXT;
823   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
824 
825   //=== VK_KHR_shader_clock ===
826   struct PhysicalDeviceShaderClockFeaturesKHR;
827 
828   //=== VK_AMD_pipeline_compiler_control ===
829   struct PipelineCompilerControlCreateInfoAMD;
830 
831   //=== VK_EXT_calibrated_timestamps ===
832   struct CalibratedTimestampInfoEXT;
833 
834   //=== VK_AMD_shader_core_properties ===
835   struct PhysicalDeviceShaderCorePropertiesAMD;
836 
837 #if defined( VK_ENABLE_BETA_EXTENSIONS )
838   //=== VK_EXT_video_decode_h265 ===
839   struct VideoDecodeH265ProfileEXT;
840   struct VideoDecodeH265CapabilitiesEXT;
841   struct VideoDecodeH265SessionCreateInfoEXT;
842   struct VideoDecodeH265SessionParametersCreateInfoEXT;
843   struct VideoDecodeH265SessionParametersAddInfoEXT;
844   struct VideoDecodeH265PictureInfoEXT;
845   struct VideoDecodeH265DpbSlotInfoEXT;
846 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
847 
848   //=== VK_AMD_memory_overallocation_behavior ===
849   struct DeviceMemoryOverallocationCreateInfoAMD;
850 
851   //=== VK_EXT_vertex_attribute_divisor ===
852   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
853   struct VertexInputBindingDivisorDescriptionEXT;
854   struct PipelineVertexInputDivisorStateCreateInfoEXT;
855   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
856 
857 #if defined( VK_USE_PLATFORM_GGP )
858   //=== VK_GGP_frame_token ===
859   struct PresentFrameTokenGGP;
860 #endif /*VK_USE_PLATFORM_GGP*/
861 
862   //=== VK_EXT_pipeline_creation_feedback ===
863   struct PipelineCreationFeedbackCreateInfoEXT;
864   struct PipelineCreationFeedbackEXT;
865 
866   //=== VK_NV_compute_shader_derivatives ===
867   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
868 
869   //=== VK_NV_mesh_shader ===
870   struct PhysicalDeviceMeshShaderFeaturesNV;
871   struct PhysicalDeviceMeshShaderPropertiesNV;
872   struct DrawMeshTasksIndirectCommandNV;
873 
874   //=== VK_NV_fragment_shader_barycentric ===
875   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
876 
877   //=== VK_NV_shader_image_footprint ===
878   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
879 
880   //=== VK_NV_scissor_exclusive ===
881   struct PipelineViewportExclusiveScissorStateCreateInfoNV;
882   struct PhysicalDeviceExclusiveScissorFeaturesNV;
883 
884   //=== VK_NV_device_diagnostic_checkpoints ===
885   struct QueueFamilyCheckpointPropertiesNV;
886   struct CheckpointDataNV;
887 
888   //=== VK_INTEL_shader_integer_functions2 ===
889   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
890 
891   //=== VK_INTEL_performance_query ===
892   union PerformanceValueDataINTEL;
893   struct PerformanceValueINTEL;
894   struct InitializePerformanceApiInfoINTEL;
895   struct QueryPoolPerformanceQueryCreateInfoINTEL;
896   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
897   struct PerformanceMarkerInfoINTEL;
898   struct PerformanceStreamMarkerInfoINTEL;
899   struct PerformanceOverrideInfoINTEL;
900   struct PerformanceConfigurationAcquireInfoINTEL;
901 
902   //=== VK_EXT_pci_bus_info ===
903   struct PhysicalDevicePCIBusInfoPropertiesEXT;
904 
905   //=== VK_AMD_display_native_hdr ===
906   struct DisplayNativeHdrSurfaceCapabilitiesAMD;
907   struct SwapchainDisplayNativeHdrCreateInfoAMD;
908 
909 #if defined( VK_USE_PLATFORM_FUCHSIA )
910   //=== VK_FUCHSIA_imagepipe_surface ===
911   struct ImagePipeSurfaceCreateInfoFUCHSIA;
912 #endif /*VK_USE_PLATFORM_FUCHSIA*/
913 
914   //=== VK_KHR_shader_terminate_invocation ===
915   struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
916 
917 #if defined( VK_USE_PLATFORM_METAL_EXT )
918   //=== VK_EXT_metal_surface ===
919   struct MetalSurfaceCreateInfoEXT;
920 #endif /*VK_USE_PLATFORM_METAL_EXT*/
921 
922   //=== VK_EXT_fragment_density_map ===
923   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
924   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
925   struct RenderPassFragmentDensityMapCreateInfoEXT;
926 
927   //=== VK_EXT_subgroup_size_control ===
928   struct PhysicalDeviceSubgroupSizeControlFeaturesEXT;
929   struct PhysicalDeviceSubgroupSizeControlPropertiesEXT;
930   struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
931 
932   //=== VK_KHR_fragment_shading_rate ===
933   struct FragmentShadingRateAttachmentInfoKHR;
934   struct PipelineFragmentShadingRateStateCreateInfoKHR;
935   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
936   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
937   struct PhysicalDeviceFragmentShadingRateKHR;
938 
939   //=== VK_AMD_shader_core_properties2 ===
940   struct PhysicalDeviceShaderCoreProperties2AMD;
941 
942   //=== VK_AMD_device_coherent_memory ===
943   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
944 
945   //=== VK_EXT_shader_image_atomic_int64 ===
946   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
947 
948   //=== VK_EXT_memory_budget ===
949   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
950 
951   //=== VK_EXT_memory_priority ===
952   struct PhysicalDeviceMemoryPriorityFeaturesEXT;
953   struct MemoryPriorityAllocateInfoEXT;
954 
955   //=== VK_KHR_surface_protected_capabilities ===
956   struct SurfaceProtectedCapabilitiesKHR;
957 
958   //=== VK_NV_dedicated_allocation_image_aliasing ===
959   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
960 
961   //=== VK_EXT_buffer_device_address ===
962   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
963   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
964   struct BufferDeviceAddressCreateInfoEXT;
965 
966   //=== VK_EXT_tooling_info ===
967   struct PhysicalDeviceToolPropertiesEXT;
968 
969   //=== VK_EXT_validation_features ===
970   struct ValidationFeaturesEXT;
971 
972   //=== VK_KHR_present_wait ===
973   struct PhysicalDevicePresentWaitFeaturesKHR;
974 
975   //=== VK_NV_cooperative_matrix ===
976   struct CooperativeMatrixPropertiesNV;
977   struct PhysicalDeviceCooperativeMatrixFeaturesNV;
978   struct PhysicalDeviceCooperativeMatrixPropertiesNV;
979 
980   //=== VK_NV_coverage_reduction_mode ===
981   struct PhysicalDeviceCoverageReductionModeFeaturesNV;
982   struct PipelineCoverageReductionStateCreateInfoNV;
983   struct FramebufferMixedSamplesCombinationNV;
984 
985   //=== VK_EXT_fragment_shader_interlock ===
986   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
987 
988   //=== VK_EXT_ycbcr_image_arrays ===
989   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
990 
991   //=== VK_EXT_provoking_vertex ===
992   struct PhysicalDeviceProvokingVertexFeaturesEXT;
993   struct PhysicalDeviceProvokingVertexPropertiesEXT;
994   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
995 
996 #if defined( VK_USE_PLATFORM_WIN32_KHR )
997   //=== VK_EXT_full_screen_exclusive ===
998   struct SurfaceFullScreenExclusiveInfoEXT;
999   struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1000   struct SurfaceFullScreenExclusiveWin32InfoEXT;
1001 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1002 
1003   //=== VK_EXT_headless_surface ===
1004   struct HeadlessSurfaceCreateInfoEXT;
1005 
1006   //=== VK_EXT_line_rasterization ===
1007   struct PhysicalDeviceLineRasterizationFeaturesEXT;
1008   struct PhysicalDeviceLineRasterizationPropertiesEXT;
1009   struct PipelineRasterizationLineStateCreateInfoEXT;
1010 
1011   //=== VK_EXT_shader_atomic_float ===
1012   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1013 
1014   //=== VK_EXT_index_type_uint8 ===
1015   struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
1016 
1017   //=== VK_EXT_extended_dynamic_state ===
1018   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1019 
1020   //=== VK_KHR_pipeline_executable_properties ===
1021   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1022   struct PipelineInfoKHR;
1023   struct PipelineExecutablePropertiesKHR;
1024   struct PipelineExecutableInfoKHR;
1025   union PipelineExecutableStatisticValueKHR;
1026   struct PipelineExecutableStatisticKHR;
1027   struct PipelineExecutableInternalRepresentationKHR;
1028 
1029   //=== VK_EXT_shader_atomic_float2 ===
1030   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1031 
1032   //=== VK_EXT_shader_demote_to_helper_invocation ===
1033   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
1034 
1035   //=== VK_NV_device_generated_commands ===
1036   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1037   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1038   struct GraphicsShaderGroupCreateInfoNV;
1039   struct GraphicsPipelineShaderGroupsCreateInfoNV;
1040   struct BindShaderGroupIndirectCommandNV;
1041   struct BindIndexBufferIndirectCommandNV;
1042   struct BindVertexBufferIndirectCommandNV;
1043   struct SetStateFlagsIndirectCommandNV;
1044   struct IndirectCommandsStreamNV;
1045   struct IndirectCommandsLayoutTokenNV;
1046   struct IndirectCommandsLayoutCreateInfoNV;
1047   struct GeneratedCommandsInfoNV;
1048   struct GeneratedCommandsMemoryRequirementsInfoNV;
1049 
1050   //=== VK_NV_inherited_viewport_scissor ===
1051   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1052   struct CommandBufferInheritanceViewportScissorInfoNV;
1053 
1054   //=== VK_KHR_shader_integer_dot_product ===
1055   struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
1056   struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
1057 
1058   //=== VK_EXT_texel_buffer_alignment ===
1059   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1060   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
1061 
1062   //=== VK_QCOM_render_pass_transform ===
1063   struct RenderPassTransformBeginInfoQCOM;
1064   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1065 
1066   //=== VK_EXT_device_memory_report ===
1067   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1068   struct DeviceDeviceMemoryReportCreateInfoEXT;
1069   struct DeviceMemoryReportCallbackDataEXT;
1070 
1071   //=== VK_EXT_robustness2 ===
1072   struct PhysicalDeviceRobustness2FeaturesEXT;
1073   struct PhysicalDeviceRobustness2PropertiesEXT;
1074 
1075   //=== VK_EXT_custom_border_color ===
1076   struct SamplerCustomBorderColorCreateInfoEXT;
1077   struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1078   struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1079 
1080   //=== VK_KHR_pipeline_library ===
1081   struct PipelineLibraryCreateInfoKHR;
1082 
1083   //=== VK_KHR_present_id ===
1084   struct PresentIdKHR;
1085   struct PhysicalDevicePresentIdFeaturesKHR;
1086 
1087   //=== VK_EXT_private_data ===
1088   struct PhysicalDevicePrivateDataFeaturesEXT;
1089   struct DevicePrivateDataCreateInfoEXT;
1090   struct PrivateDataSlotCreateInfoEXT;
1091 
1092   //=== VK_EXT_pipeline_creation_cache_control ===
1093   struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
1094 
1095 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1096   //=== VK_KHR_video_encode_queue ===
1097   struct VideoEncodeInfoKHR;
1098   struct VideoEncodeRateControlInfoKHR;
1099 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1100 
1101   //=== VK_NV_device_diagnostics_config ===
1102   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1103   struct DeviceDiagnosticsConfigCreateInfoNV;
1104 
1105   //=== VK_KHR_synchronization2 ===
1106   struct MemoryBarrier2KHR;
1107   struct BufferMemoryBarrier2KHR;
1108   struct ImageMemoryBarrier2KHR;
1109   struct DependencyInfoKHR;
1110   struct SubmitInfo2KHR;
1111   struct SemaphoreSubmitInfoKHR;
1112   struct CommandBufferSubmitInfoKHR;
1113   struct PhysicalDeviceSynchronization2FeaturesKHR;
1114   struct QueueFamilyCheckpointProperties2NV;
1115   struct CheckpointData2NV;
1116 
1117   //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1118   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1119 
1120   //=== VK_KHR_zero_initialize_workgroup_memory ===
1121   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
1122 
1123   //=== VK_NV_fragment_shading_rate_enums ===
1124   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1125   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1126   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1127 
1128   //=== VK_NV_ray_tracing_motion_blur ===
1129   struct AccelerationStructureGeometryMotionTrianglesDataNV;
1130   struct AccelerationStructureMotionInfoNV;
1131   struct AccelerationStructureMotionInstanceNV;
1132   union AccelerationStructureMotionInstanceDataNV;
1133   struct AccelerationStructureMatrixMotionInstanceNV;
1134   struct AccelerationStructureSRTMotionInstanceNV;
1135   struct SRTDataNV;
1136   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1137 
1138   //=== VK_EXT_ycbcr_2plane_444_formats ===
1139   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1140 
1141   //=== VK_EXT_fragment_density_map2 ===
1142   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1143   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1144 
1145   //=== VK_QCOM_rotated_copy_commands ===
1146   struct CopyCommandTransformInfoQCOM;
1147 
1148   //=== VK_EXT_image_robustness ===
1149   struct PhysicalDeviceImageRobustnessFeaturesEXT;
1150 
1151   //=== VK_KHR_workgroup_memory_explicit_layout ===
1152   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1153 
1154   //=== VK_KHR_copy_commands2 ===
1155   struct CopyBufferInfo2KHR;
1156   struct CopyImageInfo2KHR;
1157   struct CopyBufferToImageInfo2KHR;
1158   struct CopyImageToBufferInfo2KHR;
1159   struct BlitImageInfo2KHR;
1160   struct ResolveImageInfo2KHR;
1161   struct BufferCopy2KHR;
1162   struct ImageCopy2KHR;
1163   struct ImageBlit2KHR;
1164   struct BufferImageCopy2KHR;
1165   struct ImageResolve2KHR;
1166 
1167   //=== VK_EXT_4444_formats ===
1168   struct PhysicalDevice4444FormatsFeaturesEXT;
1169 
1170   //=== VK_EXT_rgba10x6_formats ===
1171   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1172 
1173 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1174   //=== VK_EXT_directfb_surface ===
1175   struct DirectFBSurfaceCreateInfoEXT;
1176 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1177 
1178   //=== VK_KHR_ray_tracing_pipeline ===
1179   struct RayTracingShaderGroupCreateInfoKHR;
1180   struct RayTracingPipelineCreateInfoKHR;
1181   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
1182   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
1183   struct StridedDeviceAddressRegionKHR;
1184   struct TraceRaysIndirectCommandKHR;
1185   struct RayTracingPipelineInterfaceCreateInfoKHR;
1186 
1187   //=== VK_KHR_ray_query ===
1188   struct PhysicalDeviceRayQueryFeaturesKHR;
1189 
1190   //=== VK_VALVE_mutable_descriptor_type ===
1191   struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
1192   struct MutableDescriptorTypeListVALVE;
1193   struct MutableDescriptorTypeCreateInfoVALVE;
1194 
1195   //=== VK_EXT_vertex_input_dynamic_state ===
1196   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1197   struct VertexInputBindingDescription2EXT;
1198   struct VertexInputAttributeDescription2EXT;
1199 
1200   //=== VK_EXT_physical_device_drm ===
1201   struct PhysicalDeviceDrmPropertiesEXT;
1202 
1203   //=== VK_EXT_primitive_topology_list_restart ===
1204   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1205 
1206   //=== VK_KHR_format_feature_flags2 ===
1207   struct FormatProperties3KHR;
1208 
1209 #if defined( VK_USE_PLATFORM_FUCHSIA )
1210   //=== VK_FUCHSIA_external_memory ===
1211   struct ImportMemoryZirconHandleInfoFUCHSIA;
1212   struct MemoryZirconHandlePropertiesFUCHSIA;
1213   struct MemoryGetZirconHandleInfoFUCHSIA;
1214 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1215 
1216 #if defined( VK_USE_PLATFORM_FUCHSIA )
1217   //=== VK_FUCHSIA_external_semaphore ===
1218   struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1219   struct SemaphoreGetZirconHandleInfoFUCHSIA;
1220 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1221 
1222 #if defined( VK_USE_PLATFORM_FUCHSIA )
1223   //=== VK_FUCHSIA_buffer_collection ===
1224   struct BufferCollectionCreateInfoFUCHSIA;
1225   struct ImportMemoryBufferCollectionFUCHSIA;
1226   struct BufferCollectionImageCreateInfoFUCHSIA;
1227   struct BufferConstraintsInfoFUCHSIA;
1228   struct BufferCollectionBufferCreateInfoFUCHSIA;
1229   struct BufferCollectionPropertiesFUCHSIA;
1230   struct SysmemColorSpaceFUCHSIA;
1231   struct ImageConstraintsInfoFUCHSIA;
1232   struct ImageFormatConstraintsInfoFUCHSIA;
1233   struct BufferCollectionConstraintsInfoFUCHSIA;
1234 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1235 
1236   //=== VK_HUAWEI_subpass_shading ===
1237   struct SubpassShadingPipelineCreateInfoHUAWEI;
1238   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1239   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1240 
1241   //=== VK_HUAWEI_invocation_mask ===
1242   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1243 
1244   //=== VK_NV_external_memory_rdma ===
1245   struct MemoryGetRemoteAddressInfoNV;
1246   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1247 
1248   //=== VK_EXT_extended_dynamic_state2 ===
1249   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1250 
1251 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1252   //=== VK_QNX_screen_surface ===
1253   struct ScreenSurfaceCreateInfoQNX;
1254 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1255 
1256   //=== VK_EXT_color_write_enable ===
1257   struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1258   struct PipelineColorWriteCreateInfoEXT;
1259 
1260   //=== VK_EXT_global_priority_query ===
1261   struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
1262   struct QueueFamilyGlobalPriorityPropertiesEXT;
1263 
1264   //=== VK_EXT_multi_draw ===
1265   struct PhysicalDeviceMultiDrawFeaturesEXT;
1266   struct PhysicalDeviceMultiDrawPropertiesEXT;
1267   struct MultiDrawInfoEXT;
1268   struct MultiDrawIndexedInfoEXT;
1269 
1270   //=== VK_EXT_border_color_swizzle ===
1271   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1272   struct SamplerBorderColorComponentMappingCreateInfoEXT;
1273 
1274   //=== VK_EXT_pageable_device_local_memory ===
1275   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1276 
1277   //=== VK_KHR_maintenance4 ===
1278   struct PhysicalDeviceMaintenance4FeaturesKHR;
1279   struct PhysicalDeviceMaintenance4PropertiesKHR;
1280   struct DeviceBufferMemoryRequirementsKHR;
1281   struct DeviceImageMemoryRequirementsKHR;
1282 
1283   //===============
1284   //=== HANDLEs ===
1285   //===============
1286 
1287   class SurfaceKHR
1288   {
1289   public:
1290     using CType      = VkSurfaceKHR;
1291     using NativeType = VkSurfaceKHR;
1292 
1293     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1294       VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
1295     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1296       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
1297 
1298   public:
1299     VULKAN_HPP_CONSTEXPR         SurfaceKHR() = default;
SurfaceKHR(std::nullptr_t)1300     VULKAN_HPP_CONSTEXPR         SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
SurfaceKHR(VkSurfaceKHR surfaceKHR)1301     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR )
1302     {}
1303 
1304 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSurfaceKHR surfaceKHR)1305     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
1306     {
1307       m_surfaceKHR = surfaceKHR;
1308       return *this;
1309     }
1310 #endif
1311 
operator =(std::nullptr_t)1312     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1313     {
1314       m_surfaceKHR = {};
1315       return *this;
1316     }
1317 
1318 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1319     auto operator<=>( SurfaceKHR const & ) const = default;
1320 #else
operator ==(SurfaceKHR const & rhs) const1321     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1322     {
1323       return m_surfaceKHR == rhs.m_surfaceKHR;
1324     }
1325 
operator !=(SurfaceKHR const & rhs) const1326     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1327     {
1328       return m_surfaceKHR != rhs.m_surfaceKHR;
1329     }
1330 
operator <(SurfaceKHR const & rhs) const1331     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1332     {
1333       return m_surfaceKHR < rhs.m_surfaceKHR;
1334     }
1335 #endif
1336 
operator VkSurfaceKHR() const1337     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
1338     {
1339       return m_surfaceKHR;
1340     }
1341 
operator bool() const1342     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1343     {
1344       return m_surfaceKHR != VK_NULL_HANDLE;
1345     }
1346 
operator !() const1347     bool operator!() const VULKAN_HPP_NOEXCEPT
1348     {
1349       return m_surfaceKHR == VK_NULL_HANDLE;
1350     }
1351 
1352   private:
1353     VkSurfaceKHR m_surfaceKHR = {};
1354   };
1355   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ),
1356                             "handle and wrapper have different size!" );
1357   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceKHR>::value,
1358                             "SurfaceKHR is not nothrow_move_constructible!" );
1359 
1360   template <>
1361   struct VULKAN_HPP_DEPRECATED(
1362     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSurfaceKHR>
1363   {
1364     using type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1365   };
1366 
1367   template <>
1368   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
1369   {
1370     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1371   };
1372 
1373   template <>
1374   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1375                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
1376   {
1377     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1378   };
1379 
1380   template <>
1381   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
1382   {
1383     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1384   };
1385 
1386   class DebugReportCallbackEXT
1387   {
1388   public:
1389     using CType      = VkDebugReportCallbackEXT;
1390     using NativeType = VkDebugReportCallbackEXT;
1391 
1392     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1393       VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
1394     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1395       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
1396 
1397   public:
1398     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
DebugReportCallbackEXT(std::nullptr_t)1399     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1400     VULKAN_HPP_TYPESAFE_EXPLICIT
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)1401       DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1402       : m_debugReportCallbackEXT( debugReportCallbackEXT )
1403     {}
1404 
1405 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)1406     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1407     {
1408       m_debugReportCallbackEXT = debugReportCallbackEXT;
1409       return *this;
1410     }
1411 #endif
1412 
operator =(std::nullptr_t)1413     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1414     {
1415       m_debugReportCallbackEXT = {};
1416       return *this;
1417     }
1418 
1419 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1420     auto operator<=>( DebugReportCallbackEXT const & ) const = default;
1421 #else
operator ==(DebugReportCallbackEXT const & rhs) const1422     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1423     {
1424       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
1425     }
1426 
operator !=(DebugReportCallbackEXT const & rhs) const1427     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1428     {
1429       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
1430     }
1431 
operator <(DebugReportCallbackEXT const & rhs) const1432     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1433     {
1434       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
1435     }
1436 #endif
1437 
operator VkDebugReportCallbackEXT() const1438     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
1439     {
1440       return m_debugReportCallbackEXT;
1441     }
1442 
operator bool() const1443     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1444     {
1445       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
1446     }
1447 
operator !() const1448     bool operator!() const VULKAN_HPP_NOEXCEPT
1449     {
1450       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
1451     }
1452 
1453   private:
1454     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
1455   };
1456   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) ==
1457                               sizeof( VkDebugReportCallbackEXT ),
1458                             "handle and wrapper have different size!" );
1459   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::value,
1460                             "DebugReportCallbackEXT is not nothrow_move_constructible!" );
1461 
1462   template <>
1463   struct VULKAN_HPP_DEPRECATED(
1464     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugReportCallbackEXT>
1465   {
1466     using type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1467   };
1468 
1469   template <>
1470   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
1471   {
1472     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1473   };
1474 
1475   template <>
1476   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1477                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
1478   {
1479     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1480   };
1481 
1482   template <>
1483   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
1484   {
1485     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1486   };
1487 
1488   class DebugUtilsMessengerEXT
1489   {
1490   public:
1491     using CType      = VkDebugUtilsMessengerEXT;
1492     using NativeType = VkDebugUtilsMessengerEXT;
1493 
1494     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1495       VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
1496     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1497       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
1498 
1499   public:
1500     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
DebugUtilsMessengerEXT(std::nullptr_t)1501     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1502     VULKAN_HPP_TYPESAFE_EXPLICIT
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1503       DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1504       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
1505     {}
1506 
1507 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1508     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1509     {
1510       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
1511       return *this;
1512     }
1513 #endif
1514 
operator =(std::nullptr_t)1515     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1516     {
1517       m_debugUtilsMessengerEXT = {};
1518       return *this;
1519     }
1520 
1521 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1522     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
1523 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const1524     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1525     {
1526       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
1527     }
1528 
operator !=(DebugUtilsMessengerEXT const & rhs) const1529     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1530     {
1531       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
1532     }
1533 
operator <(DebugUtilsMessengerEXT const & rhs) const1534     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1535     {
1536       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
1537     }
1538 #endif
1539 
operator VkDebugUtilsMessengerEXT() const1540     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
1541     {
1542       return m_debugUtilsMessengerEXT;
1543     }
1544 
operator bool() const1545     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1546     {
1547       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
1548     }
1549 
operator !() const1550     bool operator!() const VULKAN_HPP_NOEXCEPT
1551     {
1552       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
1553     }
1554 
1555   private:
1556     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
1557   };
1558   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) ==
1559                               sizeof( VkDebugUtilsMessengerEXT ),
1560                             "handle and wrapper have different size!" );
1561   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::value,
1562                             "DebugUtilsMessengerEXT is not nothrow_move_constructible!" );
1563 
1564   template <>
1565   struct VULKAN_HPP_DEPRECATED(
1566     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugUtilsMessengerEXT>
1567   {
1568     using type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1569   };
1570 
1571   template <>
1572   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
1573   {
1574     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1575   };
1576 
1577   template <>
1578   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
1579   {
1580     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1581   };
1582 
1583   class DisplayKHR
1584   {
1585   public:
1586     using CType      = VkDisplayKHR;
1587     using NativeType = VkDisplayKHR;
1588 
1589     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1590       VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
1591     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1592       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
1593 
1594   public:
1595     VULKAN_HPP_CONSTEXPR         DisplayKHR() = default;
DisplayKHR(std::nullptr_t)1596     VULKAN_HPP_CONSTEXPR         DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DisplayKHR(VkDisplayKHR displayKHR)1597     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR )
1598     {}
1599 
1600 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayKHR displayKHR)1601     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
1602     {
1603       m_displayKHR = displayKHR;
1604       return *this;
1605     }
1606 #endif
1607 
operator =(std::nullptr_t)1608     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1609     {
1610       m_displayKHR = {};
1611       return *this;
1612     }
1613 
1614 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1615     auto operator<=>( DisplayKHR const & ) const = default;
1616 #else
operator ==(DisplayKHR const & rhs) const1617     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1618     {
1619       return m_displayKHR == rhs.m_displayKHR;
1620     }
1621 
operator !=(DisplayKHR const & rhs) const1622     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1623     {
1624       return m_displayKHR != rhs.m_displayKHR;
1625     }
1626 
operator <(DisplayKHR const & rhs) const1627     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1628     {
1629       return m_displayKHR < rhs.m_displayKHR;
1630     }
1631 #endif
1632 
operator VkDisplayKHR() const1633     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
1634     {
1635       return m_displayKHR;
1636     }
1637 
operator bool() const1638     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1639     {
1640       return m_displayKHR != VK_NULL_HANDLE;
1641     }
1642 
operator !() const1643     bool operator!() const VULKAN_HPP_NOEXCEPT
1644     {
1645       return m_displayKHR == VK_NULL_HANDLE;
1646     }
1647 
1648   private:
1649     VkDisplayKHR m_displayKHR = {};
1650   };
1651   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ),
1652                             "handle and wrapper have different size!" );
1653   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayKHR>::value,
1654                             "DisplayKHR is not nothrow_move_constructible!" );
1655 
1656   template <>
1657   struct VULKAN_HPP_DEPRECATED(
1658     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayKHR>
1659   {
1660     using type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1661   };
1662 
1663   template <>
1664   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
1665   {
1666     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1667   };
1668 
1669   template <>
1670   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1671                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
1672   {
1673     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1674   };
1675 
1676   template <>
1677   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
1678   {
1679     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1680   };
1681 
1682   class SwapchainKHR
1683   {
1684   public:
1685     using CType      = VkSwapchainKHR;
1686     using NativeType = VkSwapchainKHR;
1687 
1688     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1689       VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
1690     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1691       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
1692 
1693   public:
1694     VULKAN_HPP_CONSTEXPR         SwapchainKHR() = default;
SwapchainKHR(std::nullptr_t)1695     VULKAN_HPP_CONSTEXPR         SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
SwapchainKHR(VkSwapchainKHR swapchainKHR)1696     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1697       : m_swapchainKHR( swapchainKHR )
1698     {}
1699 
1700 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSwapchainKHR swapchainKHR)1701     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1702     {
1703       m_swapchainKHR = swapchainKHR;
1704       return *this;
1705     }
1706 #endif
1707 
operator =(std::nullptr_t)1708     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1709     {
1710       m_swapchainKHR = {};
1711       return *this;
1712     }
1713 
1714 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1715     auto operator<=>( SwapchainKHR const & ) const = default;
1716 #else
operator ==(SwapchainKHR const & rhs) const1717     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1718     {
1719       return m_swapchainKHR == rhs.m_swapchainKHR;
1720     }
1721 
operator !=(SwapchainKHR const & rhs) const1722     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1723     {
1724       return m_swapchainKHR != rhs.m_swapchainKHR;
1725     }
1726 
operator <(SwapchainKHR const & rhs) const1727     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1728     {
1729       return m_swapchainKHR < rhs.m_swapchainKHR;
1730     }
1731 #endif
1732 
operator VkSwapchainKHR() const1733     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
1734     {
1735       return m_swapchainKHR;
1736     }
1737 
operator bool() const1738     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1739     {
1740       return m_swapchainKHR != VK_NULL_HANDLE;
1741     }
1742 
operator !() const1743     bool operator!() const VULKAN_HPP_NOEXCEPT
1744     {
1745       return m_swapchainKHR == VK_NULL_HANDLE;
1746     }
1747 
1748   private:
1749     VkSwapchainKHR m_swapchainKHR = {};
1750   };
1751   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ),
1752                             "handle and wrapper have different size!" );
1753   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainKHR>::value,
1754                             "SwapchainKHR is not nothrow_move_constructible!" );
1755 
1756   template <>
1757   struct VULKAN_HPP_DEPRECATED(
1758     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSwapchainKHR>
1759   {
1760     using type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1761   };
1762 
1763   template <>
1764   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
1765   {
1766     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1767   };
1768 
1769   template <>
1770   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1771                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
1772   {
1773     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1774   };
1775 
1776   template <>
1777   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
1778   {
1779     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1780   };
1781 
1782   class Semaphore
1783   {
1784   public:
1785     using CType      = VkSemaphore;
1786     using NativeType = VkSemaphore;
1787 
1788     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1789       VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
1790     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1791       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
1792 
1793   public:
1794     VULKAN_HPP_CONSTEXPR         Semaphore() = default;
Semaphore(std::nullptr_t)1795     VULKAN_HPP_CONSTEXPR         Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Semaphore(VkSemaphore semaphore)1796     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
1797 
1798 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSemaphore semaphore)1799     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
1800     {
1801       m_semaphore = semaphore;
1802       return *this;
1803     }
1804 #endif
1805 
operator =(std::nullptr_t)1806     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1807     {
1808       m_semaphore = {};
1809       return *this;
1810     }
1811 
1812 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1813     auto operator<=>( Semaphore const & ) const = default;
1814 #else
operator ==(Semaphore const & rhs) const1815     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1816     {
1817       return m_semaphore == rhs.m_semaphore;
1818     }
1819 
operator !=(Semaphore const & rhs) const1820     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1821     {
1822       return m_semaphore != rhs.m_semaphore;
1823     }
1824 
operator <(Semaphore const & rhs) const1825     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1826     {
1827       return m_semaphore < rhs.m_semaphore;
1828     }
1829 #endif
1830 
operator VkSemaphore() const1831     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
1832     {
1833       return m_semaphore;
1834     }
1835 
operator bool() const1836     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1837     {
1838       return m_semaphore != VK_NULL_HANDLE;
1839     }
1840 
operator !() const1841     bool operator!() const VULKAN_HPP_NOEXCEPT
1842     {
1843       return m_semaphore == VK_NULL_HANDLE;
1844     }
1845 
1846   private:
1847     VkSemaphore m_semaphore = {};
1848   };
1849   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ),
1850                             "handle and wrapper have different size!" );
1851   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Semaphore>::value,
1852                             "Semaphore is not nothrow_move_constructible!" );
1853 
1854   template <>
1855   struct VULKAN_HPP_DEPRECATED(
1856     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSemaphore>
1857   {
1858     using type = VULKAN_HPP_NAMESPACE::Semaphore;
1859   };
1860 
1861   template <>
1862   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
1863   {
1864     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1865   };
1866 
1867   template <>
1868   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1869                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
1870   {
1871     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1872   };
1873 
1874   template <>
1875   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
1876   {
1877     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1878   };
1879 
1880   class Fence
1881   {
1882   public:
1883     using CType      = VkFence;
1884     using NativeType = VkFence;
1885 
1886     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1887       VULKAN_HPP_NAMESPACE::ObjectType::eFence;
1888     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1889       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
1890 
1891   public:
1892     VULKAN_HPP_CONSTEXPR         Fence() = default;
Fence(std::nullptr_t)1893     VULKAN_HPP_CONSTEXPR         Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Fence(VkFence fence)1894     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
1895 
1896 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFence fence)1897     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
1898     {
1899       m_fence = fence;
1900       return *this;
1901     }
1902 #endif
1903 
operator =(std::nullptr_t)1904     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1905     {
1906       m_fence = {};
1907       return *this;
1908     }
1909 
1910 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1911     auto operator<=>( Fence const & ) const = default;
1912 #else
operator ==(Fence const & rhs) const1913     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1914     {
1915       return m_fence == rhs.m_fence;
1916     }
1917 
operator !=(Fence const & rhs) const1918     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1919     {
1920       return m_fence != rhs.m_fence;
1921     }
1922 
operator <(Fence const & rhs) const1923     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1924     {
1925       return m_fence < rhs.m_fence;
1926     }
1927 #endif
1928 
operator VkFence() const1929     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
1930     {
1931       return m_fence;
1932     }
1933 
operator bool() const1934     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1935     {
1936       return m_fence != VK_NULL_HANDLE;
1937     }
1938 
operator !() const1939     bool operator!() const VULKAN_HPP_NOEXCEPT
1940     {
1941       return m_fence == VK_NULL_HANDLE;
1942     }
1943 
1944   private:
1945     VkFence m_fence = {};
1946   };
1947   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ),
1948                             "handle and wrapper have different size!" );
1949   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Fence>::value,
1950                             "Fence is not nothrow_move_constructible!" );
1951 
1952   template <>
1953   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFence>
1954   {
1955     using type = VULKAN_HPP_NAMESPACE::Fence;
1956   };
1957 
1958   template <>
1959   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
1960   {
1961     using Type = VULKAN_HPP_NAMESPACE::Fence;
1962   };
1963 
1964   template <>
1965   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
1966   {
1967     using Type = VULKAN_HPP_NAMESPACE::Fence;
1968   };
1969 
1970   template <>
1971   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
1972   {
1973     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1974   };
1975 
1976   class PerformanceConfigurationINTEL
1977   {
1978   public:
1979     using CType      = VkPerformanceConfigurationINTEL;
1980     using NativeType = VkPerformanceConfigurationINTEL;
1981 
1982     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1983       VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
1984     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1985       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
1986 
1987   public:
1988     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
PerformanceConfigurationINTEL(std::nullptr_t)1989     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1990     VULKAN_HPP_TYPESAFE_EXPLICIT
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)1991       PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
1992       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
1993     {}
1994 
1995 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1996     PerformanceConfigurationINTEL &
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)1997       operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
1998     {
1999       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2000       return *this;
2001     }
2002 #endif
2003 
operator =(std::nullptr_t)2004     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2005     {
2006       m_performanceConfigurationINTEL = {};
2007       return *this;
2008     }
2009 
2010 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2011     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
2012 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const2013     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2014     {
2015       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
2016     }
2017 
operator !=(PerformanceConfigurationINTEL const & rhs) const2018     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2019     {
2020       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
2021     }
2022 
operator <(PerformanceConfigurationINTEL const & rhs) const2023     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2024     {
2025       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
2026     }
2027 #endif
2028 
operator VkPerformanceConfigurationINTEL() const2029     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
2030     {
2031       return m_performanceConfigurationINTEL;
2032     }
2033 
operator bool() const2034     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2035     {
2036       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
2037     }
2038 
operator !() const2039     bool operator!() const VULKAN_HPP_NOEXCEPT
2040     {
2041       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
2042     }
2043 
2044   private:
2045     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
2046   };
2047   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) ==
2048                               sizeof( VkPerformanceConfigurationINTEL ),
2049                             "handle and wrapper have different size!" );
2050   VULKAN_HPP_STATIC_ASSERT(
2051     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::value,
2052     "PerformanceConfigurationINTEL is not nothrow_move_constructible!" );
2053 
2054   template <>
2055   struct VULKAN_HPP_DEPRECATED(
2056     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePerformanceConfigurationINTEL>
2057   {
2058     using type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
2059   };
2060 
2061   template <>
2062   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
2063   {
2064     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
2065   };
2066 
2067   template <>
2068   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
2069   {
2070     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2071   };
2072 
2073   class QueryPool
2074   {
2075   public:
2076     using CType      = VkQueryPool;
2077     using NativeType = VkQueryPool;
2078 
2079     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2080       VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
2081     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2082       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
2083 
2084   public:
2085     VULKAN_HPP_CONSTEXPR         QueryPool() = default;
QueryPool(std::nullptr_t)2086     VULKAN_HPP_CONSTEXPR         QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
QueryPool(VkQueryPool queryPool)2087     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
2088 
2089 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueryPool queryPool)2090     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
2091     {
2092       m_queryPool = queryPool;
2093       return *this;
2094     }
2095 #endif
2096 
operator =(std::nullptr_t)2097     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2098     {
2099       m_queryPool = {};
2100       return *this;
2101     }
2102 
2103 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2104     auto operator<=>( QueryPool const & ) const = default;
2105 #else
operator ==(QueryPool const & rhs) const2106     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2107     {
2108       return m_queryPool == rhs.m_queryPool;
2109     }
2110 
operator !=(QueryPool const & rhs) const2111     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2112     {
2113       return m_queryPool != rhs.m_queryPool;
2114     }
2115 
operator <(QueryPool const & rhs) const2116     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2117     {
2118       return m_queryPool < rhs.m_queryPool;
2119     }
2120 #endif
2121 
operator VkQueryPool() const2122     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
2123     {
2124       return m_queryPool;
2125     }
2126 
operator bool() const2127     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2128     {
2129       return m_queryPool != VK_NULL_HANDLE;
2130     }
2131 
operator !() const2132     bool operator!() const VULKAN_HPP_NOEXCEPT
2133     {
2134       return m_queryPool == VK_NULL_HANDLE;
2135     }
2136 
2137   private:
2138     VkQueryPool m_queryPool = {};
2139   };
2140   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ),
2141                             "handle and wrapper have different size!" );
2142   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueryPool>::value,
2143                             "QueryPool is not nothrow_move_constructible!" );
2144 
2145   template <>
2146   struct VULKAN_HPP_DEPRECATED(
2147     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueryPool>
2148   {
2149     using type = VULKAN_HPP_NAMESPACE::QueryPool;
2150   };
2151 
2152   template <>
2153   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
2154   {
2155     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2156   };
2157 
2158   template <>
2159   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2160                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
2161   {
2162     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2163   };
2164 
2165   template <>
2166   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
2167   {
2168     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2169   };
2170 
2171   class Buffer
2172   {
2173   public:
2174     using CType      = VkBuffer;
2175     using NativeType = VkBuffer;
2176 
2177     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2178       VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
2179     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2180       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
2181 
2182   public:
2183     VULKAN_HPP_CONSTEXPR         Buffer() = default;
Buffer(std::nullptr_t)2184     VULKAN_HPP_CONSTEXPR         Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Buffer(VkBuffer buffer)2185     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
2186 
2187 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBuffer buffer)2188     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
2189     {
2190       m_buffer = buffer;
2191       return *this;
2192     }
2193 #endif
2194 
operator =(std::nullptr_t)2195     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2196     {
2197       m_buffer = {};
2198       return *this;
2199     }
2200 
2201 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2202     auto operator<=>( Buffer const & ) const = default;
2203 #else
operator ==(Buffer const & rhs) const2204     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2205     {
2206       return m_buffer == rhs.m_buffer;
2207     }
2208 
operator !=(Buffer const & rhs) const2209     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2210     {
2211       return m_buffer != rhs.m_buffer;
2212     }
2213 
operator <(Buffer const & rhs) const2214     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2215     {
2216       return m_buffer < rhs.m_buffer;
2217     }
2218 #endif
2219 
operator VkBuffer() const2220     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
2221     {
2222       return m_buffer;
2223     }
2224 
operator bool() const2225     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2226     {
2227       return m_buffer != VK_NULL_HANDLE;
2228     }
2229 
operator !() const2230     bool operator!() const VULKAN_HPP_NOEXCEPT
2231     {
2232       return m_buffer == VK_NULL_HANDLE;
2233     }
2234 
2235   private:
2236     VkBuffer m_buffer = {};
2237   };
2238   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ),
2239                             "handle and wrapper have different size!" );
2240   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Buffer>::value,
2241                             "Buffer is not nothrow_move_constructible!" );
2242 
2243   template <>
2244   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBuffer>
2245   {
2246     using type = VULKAN_HPP_NAMESPACE::Buffer;
2247   };
2248 
2249   template <>
2250   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
2251   {
2252     using Type = VULKAN_HPP_NAMESPACE::Buffer;
2253   };
2254 
2255   template <>
2256   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2257                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
2258   {
2259     using Type = VULKAN_HPP_NAMESPACE::Buffer;
2260   };
2261 
2262   template <>
2263   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
2264   {
2265     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2266   };
2267 
2268   class PipelineLayout
2269   {
2270   public:
2271     using CType      = VkPipelineLayout;
2272     using NativeType = VkPipelineLayout;
2273 
2274     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2275       VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
2276     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2277       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
2278 
2279   public:
2280     VULKAN_HPP_CONSTEXPR         PipelineLayout() = default;
PipelineLayout(std::nullptr_t)2281     VULKAN_HPP_CONSTEXPR         PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PipelineLayout(VkPipelineLayout pipelineLayout)2282     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
2283       : m_pipelineLayout( pipelineLayout )
2284     {}
2285 
2286 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineLayout pipelineLayout)2287     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
2288     {
2289       m_pipelineLayout = pipelineLayout;
2290       return *this;
2291     }
2292 #endif
2293 
operator =(std::nullptr_t)2294     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2295     {
2296       m_pipelineLayout = {};
2297       return *this;
2298     }
2299 
2300 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2301     auto operator<=>( PipelineLayout const & ) const = default;
2302 #else
operator ==(PipelineLayout const & rhs) const2303     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2304     {
2305       return m_pipelineLayout == rhs.m_pipelineLayout;
2306     }
2307 
operator !=(PipelineLayout const & rhs) const2308     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2309     {
2310       return m_pipelineLayout != rhs.m_pipelineLayout;
2311     }
2312 
operator <(PipelineLayout const & rhs) const2313     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2314     {
2315       return m_pipelineLayout < rhs.m_pipelineLayout;
2316     }
2317 #endif
2318 
operator VkPipelineLayout() const2319     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
2320     {
2321       return m_pipelineLayout;
2322     }
2323 
operator bool() const2324     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2325     {
2326       return m_pipelineLayout != VK_NULL_HANDLE;
2327     }
2328 
operator !() const2329     bool operator!() const VULKAN_HPP_NOEXCEPT
2330     {
2331       return m_pipelineLayout == VK_NULL_HANDLE;
2332     }
2333 
2334   private:
2335     VkPipelineLayout m_pipelineLayout = {};
2336   };
2337   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ),
2338                             "handle and wrapper have different size!" );
2339   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineLayout>::value,
2340                             "PipelineLayout is not nothrow_move_constructible!" );
2341 
2342   template <>
2343   struct VULKAN_HPP_DEPRECATED(
2344     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineLayout>
2345   {
2346     using type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2347   };
2348 
2349   template <>
2350   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
2351   {
2352     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2353   };
2354 
2355   template <>
2356   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2357                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
2358   {
2359     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2360   };
2361 
2362   template <>
2363   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
2364   {
2365     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2366   };
2367 
2368   class DescriptorSet
2369   {
2370   public:
2371     using CType      = VkDescriptorSet;
2372     using NativeType = VkDescriptorSet;
2373 
2374     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2375       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
2376     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2377       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
2378 
2379   public:
2380     VULKAN_HPP_CONSTEXPR         DescriptorSet() = default;
DescriptorSet(std::nullptr_t)2381     VULKAN_HPP_CONSTEXPR         DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorSet(VkDescriptorSet descriptorSet)2382     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2383       : m_descriptorSet( descriptorSet )
2384     {}
2385 
2386 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSet descriptorSet)2387     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2388     {
2389       m_descriptorSet = descriptorSet;
2390       return *this;
2391     }
2392 #endif
2393 
operator =(std::nullptr_t)2394     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2395     {
2396       m_descriptorSet = {};
2397       return *this;
2398     }
2399 
2400 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2401     auto operator<=>( DescriptorSet const & ) const = default;
2402 #else
operator ==(DescriptorSet const & rhs) const2403     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2404     {
2405       return m_descriptorSet == rhs.m_descriptorSet;
2406     }
2407 
operator !=(DescriptorSet const & rhs) const2408     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2409     {
2410       return m_descriptorSet != rhs.m_descriptorSet;
2411     }
2412 
operator <(DescriptorSet const & rhs) const2413     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2414     {
2415       return m_descriptorSet < rhs.m_descriptorSet;
2416     }
2417 #endif
2418 
operator VkDescriptorSet() const2419     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
2420     {
2421       return m_descriptorSet;
2422     }
2423 
operator bool() const2424     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2425     {
2426       return m_descriptorSet != VK_NULL_HANDLE;
2427     }
2428 
operator !() const2429     bool operator!() const VULKAN_HPP_NOEXCEPT
2430     {
2431       return m_descriptorSet == VK_NULL_HANDLE;
2432     }
2433 
2434   private:
2435     VkDescriptorSet m_descriptorSet = {};
2436   };
2437   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ),
2438                             "handle and wrapper have different size!" );
2439   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSet>::value,
2440                             "DescriptorSet is not nothrow_move_constructible!" );
2441 
2442   template <>
2443   struct VULKAN_HPP_DEPRECATED(
2444     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSet>
2445   {
2446     using type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2447   };
2448 
2449   template <>
2450   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
2451   {
2452     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2453   };
2454 
2455   template <>
2456   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2457                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
2458   {
2459     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2460   };
2461 
2462   template <>
2463   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
2464   {
2465     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2466   };
2467 
2468   class ImageView
2469   {
2470   public:
2471     using CType      = VkImageView;
2472     using NativeType = VkImageView;
2473 
2474     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2475       VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
2476     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2477       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
2478 
2479   public:
2480     VULKAN_HPP_CONSTEXPR         ImageView() = default;
ImageView(std::nullptr_t)2481     VULKAN_HPP_CONSTEXPR         ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ImageView(VkImageView imageView)2482     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
2483 
2484 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImageView imageView)2485     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
2486     {
2487       m_imageView = imageView;
2488       return *this;
2489     }
2490 #endif
2491 
operator =(std::nullptr_t)2492     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2493     {
2494       m_imageView = {};
2495       return *this;
2496     }
2497 
2498 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2499     auto operator<=>( ImageView const & ) const = default;
2500 #else
operator ==(ImageView const & rhs) const2501     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2502     {
2503       return m_imageView == rhs.m_imageView;
2504     }
2505 
operator !=(ImageView const & rhs) const2506     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2507     {
2508       return m_imageView != rhs.m_imageView;
2509     }
2510 
operator <(ImageView const & rhs) const2511     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2512     {
2513       return m_imageView < rhs.m_imageView;
2514     }
2515 #endif
2516 
operator VkImageView() const2517     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
2518     {
2519       return m_imageView;
2520     }
2521 
operator bool() const2522     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2523     {
2524       return m_imageView != VK_NULL_HANDLE;
2525     }
2526 
operator !() const2527     bool operator!() const VULKAN_HPP_NOEXCEPT
2528     {
2529       return m_imageView == VK_NULL_HANDLE;
2530     }
2531 
2532   private:
2533     VkImageView m_imageView = {};
2534   };
2535   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ),
2536                             "handle and wrapper have different size!" );
2537   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageView>::value,
2538                             "ImageView is not nothrow_move_constructible!" );
2539 
2540   template <>
2541   struct VULKAN_HPP_DEPRECATED(
2542     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImageView>
2543   {
2544     using type = VULKAN_HPP_NAMESPACE::ImageView;
2545   };
2546 
2547   template <>
2548   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
2549   {
2550     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2551   };
2552 
2553   template <>
2554   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2555                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
2556   {
2557     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2558   };
2559 
2560   template <>
2561   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
2562   {
2563     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2564   };
2565 
2566   class Pipeline
2567   {
2568   public:
2569     using CType      = VkPipeline;
2570     using NativeType = VkPipeline;
2571 
2572     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2573       VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
2574     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2575       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
2576 
2577   public:
2578     VULKAN_HPP_CONSTEXPR         Pipeline() = default;
Pipeline(std::nullptr_t)2579     VULKAN_HPP_CONSTEXPR         Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Pipeline(VkPipeline pipeline)2580     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
2581 
2582 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipeline pipeline)2583     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
2584     {
2585       m_pipeline = pipeline;
2586       return *this;
2587     }
2588 #endif
2589 
operator =(std::nullptr_t)2590     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2591     {
2592       m_pipeline = {};
2593       return *this;
2594     }
2595 
2596 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2597     auto operator<=>( Pipeline const & ) const = default;
2598 #else
operator ==(Pipeline const & rhs) const2599     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2600     {
2601       return m_pipeline == rhs.m_pipeline;
2602     }
2603 
operator !=(Pipeline const & rhs) const2604     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2605     {
2606       return m_pipeline != rhs.m_pipeline;
2607     }
2608 
operator <(Pipeline const & rhs) const2609     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2610     {
2611       return m_pipeline < rhs.m_pipeline;
2612     }
2613 #endif
2614 
operator VkPipeline() const2615     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
2616     {
2617       return m_pipeline;
2618     }
2619 
operator bool() const2620     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2621     {
2622       return m_pipeline != VK_NULL_HANDLE;
2623     }
2624 
operator !() const2625     bool operator!() const VULKAN_HPP_NOEXCEPT
2626     {
2627       return m_pipeline == VK_NULL_HANDLE;
2628     }
2629 
2630   private:
2631     VkPipeline m_pipeline = {};
2632   };
2633   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ),
2634                             "handle and wrapper have different size!" );
2635   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Pipeline>::value,
2636                             "Pipeline is not nothrow_move_constructible!" );
2637 
2638   template <>
2639   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipeline>
2640   {
2641     using type = VULKAN_HPP_NAMESPACE::Pipeline;
2642   };
2643 
2644   template <>
2645   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
2646   {
2647     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2648   };
2649 
2650   template <>
2651   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2652                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
2653   {
2654     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2655   };
2656 
2657   template <>
2658   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
2659   {
2660     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2661   };
2662 
2663   class Image
2664   {
2665   public:
2666     using CType      = VkImage;
2667     using NativeType = VkImage;
2668 
2669     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2670       VULKAN_HPP_NAMESPACE::ObjectType::eImage;
2671     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2672       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
2673 
2674   public:
2675     VULKAN_HPP_CONSTEXPR         Image() = default;
Image(std::nullptr_t)2676     VULKAN_HPP_CONSTEXPR         Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Image(VkImage image)2677     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
2678 
2679 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImage image)2680     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
2681     {
2682       m_image = image;
2683       return *this;
2684     }
2685 #endif
2686 
operator =(std::nullptr_t)2687     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2688     {
2689       m_image = {};
2690       return *this;
2691     }
2692 
2693 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2694     auto operator<=>( Image const & ) const = default;
2695 #else
operator ==(Image const & rhs) const2696     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2697     {
2698       return m_image == rhs.m_image;
2699     }
2700 
operator !=(Image const & rhs) const2701     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2702     {
2703       return m_image != rhs.m_image;
2704     }
2705 
operator <(Image const & rhs) const2706     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2707     {
2708       return m_image < rhs.m_image;
2709     }
2710 #endif
2711 
operator VkImage() const2712     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
2713     {
2714       return m_image;
2715     }
2716 
operator bool() const2717     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2718     {
2719       return m_image != VK_NULL_HANDLE;
2720     }
2721 
operator !() const2722     bool operator!() const VULKAN_HPP_NOEXCEPT
2723     {
2724       return m_image == VK_NULL_HANDLE;
2725     }
2726 
2727   private:
2728     VkImage m_image = {};
2729   };
2730   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ),
2731                             "handle and wrapper have different size!" );
2732   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Image>::value,
2733                             "Image is not nothrow_move_constructible!" );
2734 
2735   template <>
2736   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImage>
2737   {
2738     using type = VULKAN_HPP_NAMESPACE::Image;
2739   };
2740 
2741   template <>
2742   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
2743   {
2744     using Type = VULKAN_HPP_NAMESPACE::Image;
2745   };
2746 
2747   template <>
2748   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
2749   {
2750     using Type = VULKAN_HPP_NAMESPACE::Image;
2751   };
2752 
2753   template <>
2754   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
2755   {
2756     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2757   };
2758 
2759   class AccelerationStructureNV
2760   {
2761   public:
2762     using CType      = VkAccelerationStructureNV;
2763     using NativeType = VkAccelerationStructureNV;
2764 
2765     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2766       VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
2767     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2768       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
2769 
2770   public:
2771     VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
AccelerationStructureNV(std::nullptr_t)2772     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2773     VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)2774       AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2775       : m_accelerationStructureNV( accelerationStructureNV )
2776     {}
2777 
2778 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkAccelerationStructureNV accelerationStructureNV)2779     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2780     {
2781       m_accelerationStructureNV = accelerationStructureNV;
2782       return *this;
2783     }
2784 #endif
2785 
operator =(std::nullptr_t)2786     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2787     {
2788       m_accelerationStructureNV = {};
2789       return *this;
2790     }
2791 
2792 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2793     auto operator<=>( AccelerationStructureNV const & ) const = default;
2794 #else
operator ==(AccelerationStructureNV const & rhs) const2795     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2796     {
2797       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
2798     }
2799 
operator !=(AccelerationStructureNV const & rhs) const2800     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2801     {
2802       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
2803     }
2804 
operator <(AccelerationStructureNV const & rhs) const2805     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2806     {
2807       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
2808     }
2809 #endif
2810 
operator VkAccelerationStructureNV() const2811     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
2812     {
2813       return m_accelerationStructureNV;
2814     }
2815 
operator bool() const2816     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2817     {
2818       return m_accelerationStructureNV != VK_NULL_HANDLE;
2819     }
2820 
operator !() const2821     bool operator!() const VULKAN_HPP_NOEXCEPT
2822     {
2823       return m_accelerationStructureNV == VK_NULL_HANDLE;
2824     }
2825 
2826   private:
2827     VkAccelerationStructureNV m_accelerationStructureNV = {};
2828   };
2829   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) ==
2830                               sizeof( VkAccelerationStructureNV ),
2831                             "handle and wrapper have different size!" );
2832   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::value,
2833                             "AccelerationStructureNV is not nothrow_move_constructible!" );
2834 
2835   template <>
2836   struct VULKAN_HPP_DEPRECATED(
2837     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureNV>
2838   {
2839     using type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2840   };
2841 
2842   template <>
2843   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
2844   {
2845     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2846   };
2847 
2848   template <>
2849   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2850                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
2851   {
2852     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2853   };
2854 
2855   template <>
2856   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
2857   {
2858     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2859   };
2860 
2861   class DescriptorUpdateTemplate
2862   {
2863   public:
2864     using CType      = VkDescriptorUpdateTemplate;
2865     using NativeType = VkDescriptorUpdateTemplate;
2866 
2867     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2868       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
2869     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2870       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
2871 
2872   public:
2873     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
DescriptorUpdateTemplate(std::nullptr_t)2874     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2875     VULKAN_HPP_TYPESAFE_EXPLICIT
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)2876       DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
2877       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
2878     {}
2879 
2880 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)2881     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
2882     {
2883       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
2884       return *this;
2885     }
2886 #endif
2887 
operator =(std::nullptr_t)2888     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2889     {
2890       m_descriptorUpdateTemplate = {};
2891       return *this;
2892     }
2893 
2894 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2895     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
2896 #else
operator ==(DescriptorUpdateTemplate const & rhs) const2897     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2898     {
2899       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
2900     }
2901 
operator !=(DescriptorUpdateTemplate const & rhs) const2902     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2903     {
2904       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
2905     }
2906 
operator <(DescriptorUpdateTemplate const & rhs) const2907     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2908     {
2909       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
2910     }
2911 #endif
2912 
operator VkDescriptorUpdateTemplate() const2913     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
2914     {
2915       return m_descriptorUpdateTemplate;
2916     }
2917 
operator bool() const2918     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2919     {
2920       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
2921     }
2922 
operator !() const2923     bool operator!() const VULKAN_HPP_NOEXCEPT
2924     {
2925       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
2926     }
2927 
2928   private:
2929     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
2930   };
2931   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) ==
2932                               sizeof( VkDescriptorUpdateTemplate ),
2933                             "handle and wrapper have different size!" );
2934   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::value,
2935                             "DescriptorUpdateTemplate is not nothrow_move_constructible!" );
2936 
2937   template <>
2938   struct VULKAN_HPP_DEPRECATED(
2939     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorUpdateTemplate>
2940   {
2941     using type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2942   };
2943 
2944   template <>
2945   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
2946   {
2947     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2948   };
2949 
2950   template <>
2951   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2952                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
2953   {
2954     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2955   };
2956 
2957   template <>
2958   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
2959   {
2960     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2961   };
2962   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
2963 
2964   class Event
2965   {
2966   public:
2967     using CType      = VkEvent;
2968     using NativeType = VkEvent;
2969 
2970     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2971       VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
2972     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2973       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
2974 
2975   public:
2976     VULKAN_HPP_CONSTEXPR         Event() = default;
Event(std::nullptr_t)2977     VULKAN_HPP_CONSTEXPR         Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Event(VkEvent event)2978     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
2979 
2980 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkEvent event)2981     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
2982     {
2983       m_event = event;
2984       return *this;
2985     }
2986 #endif
2987 
operator =(std::nullptr_t)2988     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2989     {
2990       m_event = {};
2991       return *this;
2992     }
2993 
2994 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2995     auto operator<=>( Event const & ) const = default;
2996 #else
operator ==(Event const & rhs) const2997     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
2998     {
2999       return m_event == rhs.m_event;
3000     }
3001 
operator !=(Event const & rhs) const3002     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3003     {
3004       return m_event != rhs.m_event;
3005     }
3006 
operator <(Event const & rhs) const3007     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3008     {
3009       return m_event < rhs.m_event;
3010     }
3011 #endif
3012 
operator VkEvent() const3013     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
3014     {
3015       return m_event;
3016     }
3017 
operator bool() const3018     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3019     {
3020       return m_event != VK_NULL_HANDLE;
3021     }
3022 
operator !() const3023     bool operator!() const VULKAN_HPP_NOEXCEPT
3024     {
3025       return m_event == VK_NULL_HANDLE;
3026     }
3027 
3028   private:
3029     VkEvent m_event = {};
3030   };
3031   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ),
3032                             "handle and wrapper have different size!" );
3033   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Event>::value,
3034                             "Event is not nothrow_move_constructible!" );
3035 
3036   template <>
3037   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eEvent>
3038   {
3039     using type = VULKAN_HPP_NAMESPACE::Event;
3040   };
3041 
3042   template <>
3043   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
3044   {
3045     using Type = VULKAN_HPP_NAMESPACE::Event;
3046   };
3047 
3048   template <>
3049   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
3050   {
3051     using Type = VULKAN_HPP_NAMESPACE::Event;
3052   };
3053 
3054   template <>
3055   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
3056   {
3057     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3058   };
3059 
3060   class AccelerationStructureKHR
3061   {
3062   public:
3063     using CType      = VkAccelerationStructureKHR;
3064     using NativeType = VkAccelerationStructureKHR;
3065 
3066     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
3067       VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
3068     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3069       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
3070 
3071   public:
3072     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
AccelerationStructureKHR(std::nullptr_t)3073     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3074     VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)3075       AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3076       : m_accelerationStructureKHR( accelerationStructureKHR )
3077     {}
3078 
3079 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkAccelerationStructureKHR accelerationStructureKHR)3080     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3081     {
3082       m_accelerationStructureKHR = accelerationStructureKHR;
3083       return *this;
3084     }
3085 #endif
3086 
operator =(std::nullptr_t)3087     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3088     {
3089       m_accelerationStructureKHR = {};
3090       return *this;
3091     }
3092 
3093 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3094     auto operator<=>( AccelerationStructureKHR const & ) const = default;
3095 #else
operator ==(AccelerationStructureKHR const & rhs) const3096     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3097     {
3098       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
3099     }
3100 
operator !=(AccelerationStructureKHR const & rhs) const3101     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3102     {
3103       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
3104     }
3105 
operator <(AccelerationStructureKHR const & rhs) const3106     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3107     {
3108       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
3109     }
3110 #endif
3111 
operator VkAccelerationStructureKHR() const3112     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
3113     {
3114       return m_accelerationStructureKHR;
3115     }
3116 
operator bool() const3117     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3118     {
3119       return m_accelerationStructureKHR != VK_NULL_HANDLE;
3120     }
3121 
operator !() const3122     bool operator!() const VULKAN_HPP_NOEXCEPT
3123     {
3124       return m_accelerationStructureKHR == VK_NULL_HANDLE;
3125     }
3126 
3127   private:
3128     VkAccelerationStructureKHR m_accelerationStructureKHR = {};
3129   };
3130   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) ==
3131                               sizeof( VkAccelerationStructureKHR ),
3132                             "handle and wrapper have different size!" );
3133   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::value,
3134                             "AccelerationStructureKHR is not nothrow_move_constructible!" );
3135 
3136   template <>
3137   struct VULKAN_HPP_DEPRECATED(
3138     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureKHR>
3139   {
3140     using type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3141   };
3142 
3143   template <>
3144   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
3145   {
3146     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3147   };
3148 
3149   template <>
3150   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
3151                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
3152   {
3153     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3154   };
3155 
3156   template <>
3157   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
3158   {
3159     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3160   };
3161 
3162   class CommandBuffer
3163   {
3164   public:
3165     using CType      = VkCommandBuffer;
3166     using NativeType = VkCommandBuffer;
3167 
3168     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
3169       VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
3170     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3171       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
3172 
3173   public:
3174     VULKAN_HPP_CONSTEXPR         CommandBuffer() = default;
CommandBuffer(std::nullptr_t)3175     VULKAN_HPP_CONSTEXPR         CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CommandBuffer(VkCommandBuffer commandBuffer)3176     VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
3177       : m_commandBuffer( commandBuffer )
3178     {}
3179 
3180 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandBuffer commandBuffer)3181     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
3182     {
3183       m_commandBuffer = commandBuffer;
3184       return *this;
3185     }
3186 #endif
3187 
operator =(std::nullptr_t)3188     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3189     {
3190       m_commandBuffer = {};
3191       return *this;
3192     }
3193 
3194 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3195     auto operator<=>( CommandBuffer const & ) const = default;
3196 #else
operator ==(CommandBuffer const & rhs) const3197     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3198     {
3199       return m_commandBuffer == rhs.m_commandBuffer;
3200     }
3201 
operator !=(CommandBuffer const & rhs) const3202     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3203     {
3204       return m_commandBuffer != rhs.m_commandBuffer;
3205     }
3206 
operator <(CommandBuffer const & rhs) const3207     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3208     {
3209       return m_commandBuffer < rhs.m_commandBuffer;
3210     }
3211 #endif
3212 
3213     //=== VK_VERSION_1_0 ===
3214 
3215     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3216     VULKAN_HPP_NODISCARD Result
3217       begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
3218              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3219 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3221     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
3222       begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,
3223              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3224 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3225 
3226 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3227     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3228     VULKAN_HPP_NODISCARD Result
3229       end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3230 #else
3231     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3232     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
3233       end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3234 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3235 
3236 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3238     VULKAN_HPP_NODISCARD Result
3239       reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
3240              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3241 #else
3242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3243     typename ResultValueType<void>::type
3244          reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
3245                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3246 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3247 
3248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3249     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
3250                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
3251                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3252 
3253     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3254     void setViewport( uint32_t                               firstViewport,
3255                       uint32_t                               viewportCount,
3256                       const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
3257                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3258 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3259     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3260     void setViewport( uint32_t                                                 firstViewport,
3261                       ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
3262                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3264 
3265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3266     void setScissor( uint32_t                             firstScissor,
3267                      uint32_t                             scissorCount,
3268                      const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
3269                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3272     void setScissor( uint32_t                                               firstScissor,
3273                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
3274                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3275 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3276 
3277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3278     void setLineWidth( float              lineWidth,
3279                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3280 
3281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3282     void setDepthBias( float              depthBiasConstantFactor,
3283                        float              depthBiasClamp,
3284                        float              depthBiasSlopeFactor,
3285                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3286 
3287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3288     void setBlendConstants( const float        blendConstants[4],
3289                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3290 
3291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3292     void setDepthBounds( float              minDepthBounds,
3293                          float              maxDepthBounds,
3294                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3295 
3296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3297     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
3298                                 uint32_t                               compareMask,
3299                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3300 
3301     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3302     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
3303                               uint32_t                               writeMask,
3304                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3305 
3306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3307     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
3308                               uint32_t                               reference,
3309                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3310 
3311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3312     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
3313                              VULKAN_HPP_NAMESPACE::PipelineLayout        layout,
3314                              uint32_t                                    firstSet,
3315                              uint32_t                                    descriptorSetCount,
3316                              const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
3317                              uint32_t                                    dynamicOffsetCount,
3318                              const uint32_t *                            pDynamicOffsets,
3319                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3322     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                       pipelineBindPoint,
3323                              VULKAN_HPP_NAMESPACE::PipelineLayout                          layout,
3324                              uint32_t                                                      firstSet,
3325                              ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
3326                              ArrayProxy<const uint32_t> const &                            dynamicOffsets,
3327                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3328 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3329 
3330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3331     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3332                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
3333                           VULKAN_HPP_NAMESPACE::IndexType  indexType,
3334                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3335 
3336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3337     void bindVertexBuffers( uint32_t                                 firstBinding,
3338                             uint32_t                                 bindingCount,
3339                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
3340                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
3341                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3344     void bindVertexBuffers( uint32_t                                                   firstBinding,
3345                             ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
3346                             ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
3347                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3348       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3349 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3350 
3351     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3352     void draw( uint32_t           vertexCount,
3353                uint32_t           instanceCount,
3354                uint32_t           firstVertex,
3355                uint32_t           firstInstance,
3356                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3357 
3358     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3359     void drawIndexed( uint32_t           indexCount,
3360                       uint32_t           instanceCount,
3361                       uint32_t           firstIndex,
3362                       int32_t            vertexOffset,
3363                       uint32_t           firstInstance,
3364                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3365 
3366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3367     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3368                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
3369                        uint32_t                         drawCount,
3370                        uint32_t                         stride,
3371                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3372 
3373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3374     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3375                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
3376                               uint32_t                         drawCount,
3377                               uint32_t                         stride,
3378                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3379 
3380     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3381     void dispatch( uint32_t           groupCountX,
3382                    uint32_t           groupCountY,
3383                    uint32_t           groupCountZ,
3384                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3385 
3386     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3387     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3388                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
3389                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3390 
3391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3392     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
3393                      VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
3394                      uint32_t                                 regionCount,
3395                      const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
3396                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3399     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
3400                      VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
3401                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
3402                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3403 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3404 
3405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3406     void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
3407                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
3408                     VULKAN_HPP_NAMESPACE::Image             dstImage,
3409                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
3410                     uint32_t                                regionCount,
3411                     const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
3412                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3415     void copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
3416                     VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
3417                     VULKAN_HPP_NAMESPACE::Image                               dstImage,
3418                     VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
3419                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
3420                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3421 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3422 
3423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3424     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
3425                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
3426                     VULKAN_HPP_NAMESPACE::Image             dstImage,
3427                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
3428                     uint32_t                                regionCount,
3429                     const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
3430                     VULKAN_HPP_NAMESPACE::Filter            filter,
3431                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3433     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3434     void blitImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
3435                     VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
3436                     VULKAN_HPP_NAMESPACE::Image                               dstImage,
3437                     VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
3438                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
3439                     VULKAN_HPP_NAMESPACE::Filter                              filter,
3440                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3441 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3442 
3443     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3444     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
3445                             VULKAN_HPP_NAMESPACE::Image                   dstImage,
3446                             VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
3447                             uint32_t                                      regionCount,
3448                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3449                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3451     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3452     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
3453                             VULKAN_HPP_NAMESPACE::Image                                     dstImage,
3454                             VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
3455                             ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
3456                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3457 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3458 
3459     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3460     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
3461                             VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
3462                             VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
3463                             uint32_t                                      regionCount,
3464                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3465                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3466 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3467     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3468     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
3469                             VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
3470                             VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
3471                             ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
3472                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3473 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3474 
3475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3476     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3477                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3478                        VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
3479                        const void *                     pData,
3480                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3482     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3483     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3484                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3485                        ArrayProxy<const T> const &      data,
3486                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3487 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3488 
3489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3490     void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3491                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3492                      VULKAN_HPP_NAMESPACE::DeviceSize size,
3493                      uint32_t                         data,
3494                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3495 
3496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3497     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
3498                           VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,
3499                           const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,
3500                           uint32_t                                            rangeCount,
3501                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
3502                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3503 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3504     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3505     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                           image,
3506                           VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
3507                           const VULKAN_HPP_NAMESPACE::ClearColorValue &                         color,
3508                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
3509                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3510 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3511 
3512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3513     void
3514       clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
3515                               VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
3516                               const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
3517                               uint32_t                                             rangeCount,
3518                               const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
3519                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3522     void
3523       clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                           image,
3524                               VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
3525                               const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &                  depthStencil,
3526                               ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
3527                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3528 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3529 
3530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3531     void clearAttachments( uint32_t                                      attachmentCount,
3532                            const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
3533                            uint32_t                                      rectCount,
3534                            const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
3535                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3538     void clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
3539                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
3540                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3541 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3542 
3543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3544     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
3545                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
3546                        VULKAN_HPP_NAMESPACE::Image                dstImage,
3547                        VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
3548                        uint32_t                                   regionCount,
3549                        const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
3550                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3551 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3552     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3553     void resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
3554                        VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
3555                        VULKAN_HPP_NAMESPACE::Image                                  dstImage,
3556                        VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
3557                        ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
3558                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3559 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3560 
3561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3562     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
3563                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
3564                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3565 
3566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3567     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
3568                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
3569                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3570 
3571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3572     void waitEvents( uint32_t                                          eventCount,
3573                      const VULKAN_HPP_NAMESPACE::Event *               pEvents,
3574                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
3575                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
3576                      uint32_t                                          memoryBarrierCount,
3577                      const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
3578                      uint32_t                                          bufferMemoryBarrierCount,
3579                      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3580                      uint32_t                                          imageMemoryBarrierCount,
3581                      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
3582                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3585     void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
3586                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
3587                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
3588                      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
3589                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
3590                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
3591                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3592 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3593 
3594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3595     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
3596                           VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
3597                           VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
3598                           uint32_t                                          memoryBarrierCount,
3599                           const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
3600                           uint32_t                                          bufferMemoryBarrierCount,
3601                           const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3602                           uint32_t                                          imageMemoryBarrierCount,
3603                           const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
3604                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3606     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3607     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
3608                           VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
3609                           VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
3610                           ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
3611                           ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
3612                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
3613                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3614 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3615 
3616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3617     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
3618                      uint32_t                                query,
3619                      VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
3620                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3621 
3622     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3623     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3624                    uint32_t                        query,
3625                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3626 
3627     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3628     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3629                          uint32_t                        firstQuery,
3630                          uint32_t                        queryCount,
3631                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3632 
3633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3634     void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
3635                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
3636                          uint32_t                                    query,
3637                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3638 
3639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3640     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
3641                                uint32_t                               firstQuery,
3642                                uint32_t                               queryCount,
3643                                VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
3644                                VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
3645                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
3646                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
3647                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3648 
3649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3650     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
3651                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
3652                         uint32_t                               offset,
3653                         uint32_t                               size,
3654                         const void *                           pValues,
3655                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3657     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3658     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
3659                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
3660                         uint32_t                               offset,
3661                         ArrayProxy<const T> const &            values,
3662                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3663 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3664 
3665     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3666     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3667                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
3668                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3669 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3671     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
3672                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
3673                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3674 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3675 
3676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3677     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
3678                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3679 
3680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3681     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3682 
3683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3684     void executeCommands( uint32_t                                    commandBufferCount,
3685                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
3686                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3689     void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
3690                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3691 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3692 
3693     //=== VK_VERSION_1_1 ===
3694 
3695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3696     void setDeviceMask( uint32_t           deviceMask,
3697                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3698 
3699     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3700     void dispatchBase( uint32_t           baseGroupX,
3701                        uint32_t           baseGroupY,
3702                        uint32_t           baseGroupZ,
3703                        uint32_t           groupCountX,
3704                        uint32_t           groupCountY,
3705                        uint32_t           groupCountZ,
3706                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3707 
3708     //=== VK_VERSION_1_2 ===
3709 
3710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3711     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3712                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
3713                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3714                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3715                             uint32_t                         maxDrawCount,
3716                             uint32_t                         stride,
3717                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3718 
3719     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3720     void
3721       drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3722                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
3723                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3724                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3725                                 uint32_t                         maxDrawCount,
3726                                 uint32_t                         stride,
3727                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3728 
3729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3730     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3731                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
3732                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3735     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
3736                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
3737                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3738 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3739 
3740     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3741     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
3742                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
3743                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3745     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3746     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
3747                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
3748                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3749 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3750 
3751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3752     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
3753                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3754 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3755     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3756     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
3757                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3758 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3759 
3760     //=== VK_EXT_debug_marker ===
3761 
3762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3763     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
3764                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3767     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
3768                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3769 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3770 
3771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3772     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3773 
3774     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3775     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
3776                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3777 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3778     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3779     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
3780                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3781 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3782 
3783 #if defined( VK_ENABLE_BETA_EXTENSIONS )
3784     //=== VK_KHR_video_queue ===
3785 
3786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3787     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
3788                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3789 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3791     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
3792                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3793 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3794 
3795     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3796     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
3797                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3798 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3800     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
3801                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3802 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3803 
3804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3805     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
3806                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3807 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3809     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
3810                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3811 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3812 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
3813 
3814 #if defined( VK_ENABLE_BETA_EXTENSIONS )
3815     //=== VK_KHR_video_decode_queue ===
3816 
3817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3818     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
3819                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3820 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3822     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & frameInfo,
3823                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3824 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3825 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
3826 
3827     //=== VK_EXT_transform_feedback ===
3828 
3829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3830     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
3831                                           uint32_t                                 bindingCount,
3832                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
3833                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
3834                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
3835                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3836       VULKAN_HPP_NOEXCEPT;
3837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3838     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3839     void bindTransformFeedbackBuffersEXT(
3840       uint32_t                                                         firstBinding,
3841       ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &           buffers,
3842       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &       offsets,
3843       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3844       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3845 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3846 
3847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3848     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
3849                                     uint32_t                                 counterBufferCount,
3850                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
3851                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
3852                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3853       VULKAN_HPP_NOEXCEPT;
3854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3856     void beginTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
3857                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
3858                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
3859                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3860                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3861       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3862 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3863 
3864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3865     void
3866       endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
3867                                uint32_t                                 counterBufferCount,
3868                                const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
3869                                const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
3870                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3871 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3873     void endTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
3874                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
3875                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
3876                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3877                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3878       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3879 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3880 
3881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3882     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
3883                                uint32_t                                query,
3884                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
3885                                uint32_t                                index,
3886                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3887 
3888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3889     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3890                              uint32_t                        query,
3891                              uint32_t                        index,
3892                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3893 
3894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3895     void
3896       drawIndirectByteCountEXT( uint32_t                         instanceCount,
3897                                 uint32_t                         firstInstance,
3898                                 VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
3899                                 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
3900                                 uint32_t                         counterOffset,
3901                                 uint32_t                         vertexStride,
3902                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3903 
3904     //=== VK_NVX_binary_import ===
3905 
3906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3907     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
3908                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3909 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3911     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,
3912                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3913 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3914 
3915     //=== VK_AMD_draw_indirect_count ===
3916 
3917     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3918     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3919                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
3920                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3921                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3922                                uint32_t                         maxDrawCount,
3923                                uint32_t                         stride,
3924                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3925 
3926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3927     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3928                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
3929                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3930                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3931                                       uint32_t                         maxDrawCount,
3932                                       uint32_t                         stride,
3933                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3934       VULKAN_HPP_NOEXCEPT;
3935 
3936     //=== VK_KHR_device_group ===
3937 
3938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3939     void setDeviceMaskKHR( uint32_t           deviceMask,
3940                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3941 
3942     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3943     void dispatchBaseKHR( uint32_t           baseGroupX,
3944                           uint32_t           baseGroupY,
3945                           uint32_t           baseGroupZ,
3946                           uint32_t           groupCountX,
3947                           uint32_t           groupCountY,
3948                           uint32_t           groupCountZ,
3949                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3950 
3951     //=== VK_KHR_push_descriptor ===
3952 
3953     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3954     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
3955                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
3956                                uint32_t                                         set,
3957                                uint32_t                                         descriptorWriteCount,
3958                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
3959                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3960 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3961     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3962     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
3963                                VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
3964                                uint32_t                                                           set,
3965                                ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
3966                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3967 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3968 
3969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3970     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
3971                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
3972                                            uint32_t                                       set,
3973                                            const void *                                   pData,
3974                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3975       VULKAN_HPP_NOEXCEPT;
3976 
3977     //=== VK_EXT_conditional_rendering ===
3978 
3979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3980     void beginConditionalRenderingEXT(
3981       const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
3982       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3983 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3985     void beginConditionalRenderingEXT(
3986       const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
3987       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3988 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3989 
3990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3991     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3992       VULKAN_HPP_NOEXCEPT;
3993 
3994     //=== VK_NV_clip_space_w_scaling ===
3995 
3996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3997     void setViewportWScalingNV( uint32_t                                         firstViewport,
3998                                 uint32_t                                         viewportCount,
3999                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
4000                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4003     void setViewportWScalingNV( uint32_t                                                           firstViewport,
4004                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
4005                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4006 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4007 
4008     //=== VK_EXT_discard_rectangles ===
4009 
4010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4011     void
4012       setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
4013                               uint32_t                             discardRectangleCount,
4014                               const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
4015                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4016 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4018     void
4019       setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
4020                               ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
4021                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4022 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4023 
4024     //=== VK_KHR_create_renderpass2 ===
4025 
4026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4027     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4028                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
4029                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4031     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4032     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4033                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
4034                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4035 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4036 
4037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4038     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4039                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
4040                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4041 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4042     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4043     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4044                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
4045                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4046 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4047 
4048     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4049     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4050                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4052     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4053     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4054                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4055 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4056 
4057     //=== VK_EXT_debug_utils ===
4058 
4059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4060     void
4061       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
4062                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4065     void
4066       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
4067                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4068 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4069 
4070     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4071     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4072 
4073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4074     void
4075       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
4076                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4079     void
4080       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
4081                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4082 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4083 
4084     //=== VK_EXT_sample_locations ===
4085 
4086     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4087     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
4088                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4090     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4091     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
4092                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4093 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4094 
4095     //=== VK_KHR_acceleration_structure ===
4096 
4097     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4098     void buildAccelerationStructuresKHR(
4099       uint32_t                                                                     infoCount,
4100       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
4101       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
4102       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4105     void buildAccelerationStructuresKHR(
4106       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
4107       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
4108       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4109 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4110 
4111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4112     void buildAccelerationStructuresIndirectKHR(
4113       uint32_t                                                                infoCount,
4114       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
4115       const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
4116       const uint32_t *                                                        pIndirectStrides,
4117       const uint32_t * const *                                                ppMaxPrimitiveCounts,
4118       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4119 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4121     void buildAccelerationStructuresIndirectKHR(
4122       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
4123       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
4124       ArrayProxy<const uint32_t> const &                                                        indirectStrides,
4125       ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
4126       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4127 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4128 
4129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4130     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
4131                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4132       VULKAN_HPP_NOEXCEPT;
4133 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4135     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
4136                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4137       VULKAN_HPP_NOEXCEPT;
4138 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4139 
4140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4141     void copyAccelerationStructureToMemoryKHR(
4142       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
4143       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4145     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4146     void copyAccelerationStructureToMemoryKHR(
4147       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
4148       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4149 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4150 
4151     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4152     void copyMemoryToAccelerationStructureKHR(
4153       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
4154       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4157     void copyMemoryToAccelerationStructureKHR(
4158       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
4159       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4160 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4161 
4162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4163     void writeAccelerationStructuresPropertiesKHR(
4164       uint32_t                                               accelerationStructureCount,
4165       const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
4166       VULKAN_HPP_NAMESPACE::QueryType                        queryType,
4167       VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
4168       uint32_t                                               firstQuery,
4169       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4172     void writeAccelerationStructuresPropertiesKHR(
4173       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
4174       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
4175       VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
4176       uint32_t                                                                 firstQuery,
4177       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4178 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4179 
4180     //=== VK_NV_shading_rate_image ===
4181 
4182     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4183     void
4184       bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
4185                               VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
4186                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4187 
4188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4189     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
4190                                           uint32_t                                           viewportCount,
4191                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
4192                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4193       VULKAN_HPP_NOEXCEPT;
4194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4196     void setViewportShadingRatePaletteNV(
4197       uint32_t                                                             firstViewport,
4198       ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
4199       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4200 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4201 
4202     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4203     void
4204       setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
4205                               uint32_t                                                customSampleOrderCount,
4206                               const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
4207                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4208 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4209     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4210     void setCoarseSampleOrderNV(
4211       VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
4212       ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
4213       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4214 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4215 
4216     //=== VK_NV_ray_tracing ===
4217 
4218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4219     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
4220                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
4221                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
4222                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
4223                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
4224                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
4225                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
4226                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
4227                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4228       VULKAN_HPP_NOEXCEPT;
4229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4231     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
4232                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
4233                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
4234                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
4235                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
4236                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
4237                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
4238                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
4239                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4240       VULKAN_HPP_NOEXCEPT;
4241 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4242 
4243     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4244     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
4245                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
4246                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
4247                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4248       VULKAN_HPP_NOEXCEPT;
4249 
4250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4251     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
4252                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
4253                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
4254                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
4255                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
4256                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
4257                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
4258                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
4259                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
4260                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
4261                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
4262                       uint32_t                         width,
4263                       uint32_t                         height,
4264                       uint32_t                         depth,
4265                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4266 
4267     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4268     void writeAccelerationStructuresPropertiesNV(
4269       uint32_t                                              accelerationStructureCount,
4270       const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
4271       VULKAN_HPP_NAMESPACE::QueryType                       queryType,
4272       VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
4273       uint32_t                                              firstQuery,
4274       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4275 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4277     void writeAccelerationStructuresPropertiesNV(
4278       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
4279       VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
4280       VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
4281       uint32_t                                                                firstQuery,
4282       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4283 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4284 
4285     //=== VK_KHR_draw_indirect_count ===
4286 
4287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4288     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4289                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
4290                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4291                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4292                                uint32_t                         maxDrawCount,
4293                                uint32_t                         stride,
4294                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4295 
4296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4297     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4298                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
4299                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4300                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4301                                       uint32_t                         maxDrawCount,
4302                                       uint32_t                         stride,
4303                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4304       VULKAN_HPP_NOEXCEPT;
4305 
4306     //=== VK_AMD_buffer_marker ===
4307 
4308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4309     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
4310                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
4311                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
4312                                uint32_t                                    marker,
4313                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4314 
4315     //=== VK_NV_mesh_shader ===
4316 
4317     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4318     void drawMeshTasksNV( uint32_t           taskCount,
4319                           uint32_t           firstTask,
4320                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4321 
4322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4323     void
4324       drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4325                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
4326                                uint32_t                         drawCount,
4327                                uint32_t                         stride,
4328                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4329 
4330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4331     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4332                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
4333                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4334                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4335                                        uint32_t                         maxDrawCount,
4336                                        uint32_t                         stride,
4337                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4338       VULKAN_HPP_NOEXCEPT;
4339 
4340     //=== VK_NV_scissor_exclusive ===
4341 
4342     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4343     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
4344                                 uint32_t                             exclusiveScissorCount,
4345                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
4346                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4347 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4349     void setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
4350                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
4351                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4352 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4353 
4354     //=== VK_NV_device_diagnostic_checkpoints ===
4355 
4356     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4357     void setCheckpointNV( const void *       pCheckpointMarker,
4358                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4359 
4360     //=== VK_INTEL_performance_query ===
4361 
4362     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4363     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
4364       const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
4365       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4368     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4369       setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,
4370                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4371 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4372 
4373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4374     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(
4375       const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
4376       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4378     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4379     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4380       setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,
4381                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4382 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4383 
4384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4385     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(
4386       const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
4387       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4388 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4389     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4390     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4391       setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,
4392                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4393 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4394 
4395     //=== VK_KHR_fragment_shading_rate ===
4396 
4397     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4398     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
4399                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4400                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4401       VULKAN_HPP_NOEXCEPT;
4402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4404     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,
4405                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4406                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4407       VULKAN_HPP_NOEXCEPT;
4408 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4409 
4410     //=== VK_EXT_line_rasterization ===
4411 
4412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4413     void setLineStippleEXT( uint32_t           lineStippleFactor,
4414                             uint16_t           lineStipplePattern,
4415                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4416 
4417     //=== VK_EXT_extended_dynamic_state ===
4418 
4419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4420     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
4421                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4422 
4423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4424     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
4425                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4426 
4427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4428     void
4429       setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
4430                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4431 
4432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4433     void
4434       setViewportWithCountEXT( uint32_t                               viewportCount,
4435                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4436                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4439     void
4440       setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4441                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4442 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4443 
4444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4445     void
4446       setScissorWithCountEXT( uint32_t                             scissorCount,
4447                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4448                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4450     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4451     void
4452       setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4453                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4454 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4455 
4456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4457     void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
4458                                 uint32_t                                 bindingCount,
4459                                 const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
4460                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4461                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4462                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4463                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4466     void bindVertexBuffers2EXT(
4467       uint32_t                                                           firstBinding,
4468       ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
4469       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
4470       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4471       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4472       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4473 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4474 
4475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4476     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
4477                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4478 
4479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4480     void
4481       setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
4482                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4483 
4484     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4485     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
4486                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4487 
4488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4489     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
4490                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4491       VULKAN_HPP_NOEXCEPT;
4492 
4493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4494     void
4495       setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
4496                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4497 
4498     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4499     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4500                           VULKAN_HPP_NAMESPACE::StencilOp        failOp,
4501                           VULKAN_HPP_NAMESPACE::StencilOp        passOp,
4502                           VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
4503                           VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
4504                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4505 
4506     //=== VK_NV_device_generated_commands ===
4507 
4508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4509     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4510                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4511       VULKAN_HPP_NOEXCEPT;
4512 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4514     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
4515                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4516       VULKAN_HPP_NOEXCEPT;
4517 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4518 
4519     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4520     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
4521                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4522                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4523       VULKAN_HPP_NOEXCEPT;
4524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4526     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
4527                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
4528                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4529       VULKAN_HPP_NOEXCEPT;
4530 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4531 
4532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4533     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
4534                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
4535                                     uint32_t                                groupIndex,
4536                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4537       VULKAN_HPP_NOEXCEPT;
4538 
4539 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4540     //=== VK_KHR_video_encode_queue ===
4541 
4542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4543     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
4544                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4545 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4547     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
4548                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4549 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4550 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
4551 
4552     //=== VK_KHR_synchronization2 ===
4553 
4554     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4555     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
4556                        const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
4557                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4558 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4560     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
4561                        const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo,
4562                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4563 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4564 
4565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4566     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
4567                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
4568                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4569 
4570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4571     void waitEvents2KHR( uint32_t                                        eventCount,
4572                          const VULKAN_HPP_NAMESPACE::Event *             pEvents,
4573                          const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
4574                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4575 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4576     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4577     void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
4578                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
4579                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4580       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4581 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4582 
4583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4584     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
4585                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4586 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4588     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo,
4589                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4590 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4591 
4592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4593     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
4594                              VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
4595                              uint32_t                                     query,
4596                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4597 
4598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4599     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
4600                                 VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
4601                                 VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
4602                                 uint32_t                                     marker,
4603                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4604 
4605     //=== VK_NV_fragment_shading_rate_enums ===
4606 
4607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4608     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
4609                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4610                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4611       VULKAN_HPP_NOEXCEPT;
4612 
4613     //=== VK_KHR_copy_commands2 ===
4614 
4615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4616     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
4617                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4618 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4619     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4620     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR & copyBufferInfo,
4621                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4622 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4623 
4624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4625     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
4626                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4629     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR & copyImageInfo,
4630                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4631 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4632 
4633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4634     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
4635                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4638     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
4639                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4640 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4641 
4642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4643     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
4644                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4645 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4647     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
4648                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4649 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4650 
4651     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4652     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
4653                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4654 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4655     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4656     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR & blitImageInfo,
4657                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4658 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4659 
4660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4661     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
4662                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4663 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4664     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4665     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR & resolveImageInfo,
4666                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4667 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4668 
4669     //=== VK_KHR_ray_tracing_pipeline ===
4670 
4671     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4672     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
4673                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
4674                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
4675                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
4676                        uint32_t                                                    width,
4677                        uint32_t                                                    height,
4678                        uint32_t                                                    depth,
4679                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4682     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
4683                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
4684                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
4685                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
4686                        uint32_t                                                    width,
4687                        uint32_t                                                    height,
4688                        uint32_t                                                    depth,
4689                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4690 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4691 
4692     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4693     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
4694                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
4695                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
4696                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
4697                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
4698                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4699 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4701     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
4702                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
4703                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
4704                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
4705                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
4706                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4707 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4708 
4709     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4710     void setRayTracingPipelineStackSizeKHR( uint32_t           pipelineStackSize,
4711                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4712       VULKAN_HPP_NOEXCEPT;
4713 
4714     //=== VK_EXT_vertex_input_dynamic_state ===
4715 
4716     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4717     void
4718       setVertexInputEXT( uint32_t                                                        vertexBindingDescriptionCount,
4719                          const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
4720                          uint32_t vertexAttributeDescriptionCount,
4721                          const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
4722                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4725     void setVertexInputEXT(
4726       ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
4727       ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
4728       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4729 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4730 
4731     //=== VK_HUAWEI_subpass_shading ===
4732 
4733     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4734     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4735 
4736     //=== VK_HUAWEI_invocation_mask ===
4737 
4738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4739     void
4740       bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,
4741                                 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
4742                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4743 
4744     //=== VK_EXT_extended_dynamic_state2 ===
4745 
4746     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4747     void
4748       setPatchControlPointsEXT( uint32_t           patchControlPoints,
4749                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4750 
4751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4752     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
4753                                         Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4754       VULKAN_HPP_NOEXCEPT;
4755 
4756     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4757     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
4758                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4759 
4760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4761     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
4762                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4763 
4764     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4765     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
4766                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4767       VULKAN_HPP_NOEXCEPT;
4768 
4769     //=== VK_EXT_color_write_enable ===
4770 
4771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4772     void
4773       setColorWriteEnableEXT( uint32_t                             attachmentCount,
4774                               const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
4775                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4776 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4778     void
4779       setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
4780                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4781 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4782 
4783     //=== VK_EXT_multi_draw ===
4784 
4785     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4786     void drawMultiEXT( uint32_t                                       drawCount,
4787                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
4788                        uint32_t                                       instanceCount,
4789                        uint32_t                                       firstInstance,
4790                        uint32_t                                       stride,
4791                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4792 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4794     void drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
4795                        uint32_t                                                         instanceCount,
4796                        uint32_t                                                         firstInstance,
4797                        uint32_t                                                         stride,
4798                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4799 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4800 
4801     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4802     void drawMultiIndexedEXT( uint32_t                                              drawCount,
4803                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
4804                               uint32_t                                              instanceCount,
4805                               uint32_t                                              firstInstance,
4806                               uint32_t                                              stride,
4807                               const int32_t *                                       pVertexOffset,
4808                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4809 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4811     void drawMultiIndexedEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
4812                               uint32_t                                                                instanceCount,
4813                               uint32_t                                                                firstInstance,
4814                               uint32_t                                                                stride,
4815                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4816                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4817 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4818 
operator VkCommandBuffer() const4819     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
4820     {
4821       return m_commandBuffer;
4822     }
4823 
operator bool() const4824     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4825     {
4826       return m_commandBuffer != VK_NULL_HANDLE;
4827     }
4828 
operator !() const4829     bool operator!() const VULKAN_HPP_NOEXCEPT
4830     {
4831       return m_commandBuffer == VK_NULL_HANDLE;
4832     }
4833 
4834   private:
4835     VkCommandBuffer m_commandBuffer = {};
4836   };
4837   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ),
4838                             "handle and wrapper have different size!" );
4839   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandBuffer>::value,
4840                             "CommandBuffer is not nothrow_move_constructible!" );
4841 
4842   template <>
4843   struct VULKAN_HPP_DEPRECATED(
4844     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandBuffer>
4845   {
4846     using type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4847   };
4848 
4849   template <>
4850   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
4851   {
4852     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4853   };
4854 
4855   template <>
4856   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4857                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
4858   {
4859     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4860   };
4861 
4862   template <>
4863   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
4864   {
4865     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4866   };
4867 
4868   class DeviceMemory
4869   {
4870   public:
4871     using CType      = VkDeviceMemory;
4872     using NativeType = VkDeviceMemory;
4873 
4874     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4875       VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
4876     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4877       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
4878 
4879   public:
4880     VULKAN_HPP_CONSTEXPR         DeviceMemory() = default;
DeviceMemory(std::nullptr_t)4881     VULKAN_HPP_CONSTEXPR         DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DeviceMemory(VkDeviceMemory deviceMemory)4882     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
4883       : m_deviceMemory( deviceMemory )
4884     {}
4885 
4886 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeviceMemory deviceMemory)4887     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
4888     {
4889       m_deviceMemory = deviceMemory;
4890       return *this;
4891     }
4892 #endif
4893 
operator =(std::nullptr_t)4894     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4895     {
4896       m_deviceMemory = {};
4897       return *this;
4898     }
4899 
4900 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4901     auto operator<=>( DeviceMemory const & ) const = default;
4902 #else
operator ==(DeviceMemory const & rhs) const4903     bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4904     {
4905       return m_deviceMemory == rhs.m_deviceMemory;
4906     }
4907 
operator !=(DeviceMemory const & rhs) const4908     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4909     {
4910       return m_deviceMemory != rhs.m_deviceMemory;
4911     }
4912 
operator <(DeviceMemory const & rhs) const4913     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4914     {
4915       return m_deviceMemory < rhs.m_deviceMemory;
4916     }
4917 #endif
4918 
operator VkDeviceMemory() const4919     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
4920     {
4921       return m_deviceMemory;
4922     }
4923 
operator bool() const4924     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4925     {
4926       return m_deviceMemory != VK_NULL_HANDLE;
4927     }
4928 
operator !() const4929     bool operator!() const VULKAN_HPP_NOEXCEPT
4930     {
4931       return m_deviceMemory == VK_NULL_HANDLE;
4932     }
4933 
4934   private:
4935     VkDeviceMemory m_deviceMemory = {};
4936   };
4937   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ),
4938                             "handle and wrapper have different size!" );
4939   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceMemory>::value,
4940                             "DeviceMemory is not nothrow_move_constructible!" );
4941 
4942   template <>
4943   struct VULKAN_HPP_DEPRECATED(
4944     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeviceMemory>
4945   {
4946     using type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4947   };
4948 
4949   template <>
4950   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
4951   {
4952     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4953   };
4954 
4955   template <>
4956   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4957                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
4958   {
4959     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4960   };
4961 
4962   template <>
4963   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
4964   {
4965     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4966   };
4967 
4968 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4969   class VideoSessionKHR
4970   {
4971   public:
4972     using CType      = VkVideoSessionKHR;
4973     using NativeType = VkVideoSessionKHR;
4974 
4975     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4976       VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
4977     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4978       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4979 
4980   public:
4981     VULKAN_HPP_CONSTEXPR         VideoSessionKHR() = default;
VideoSessionKHR(std::nullptr_t)4982     VULKAN_HPP_CONSTEXPR         VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)4983     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
4984       : m_videoSessionKHR( videoSessionKHR )
4985     {}
4986 
4987 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionKHR videoSessionKHR)4988     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
4989     {
4990       m_videoSessionKHR = videoSessionKHR;
4991       return *this;
4992     }
4993 #  endif
4994 
operator =(std::nullptr_t)4995     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4996     {
4997       m_videoSessionKHR = {};
4998       return *this;
4999     }
5000 
5001 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5002     auto operator<=>( VideoSessionKHR const & ) const = default;
5003 #  else
operator ==(VideoSessionKHR const & rhs) const5004     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5005     {
5006       return m_videoSessionKHR == rhs.m_videoSessionKHR;
5007     }
5008 
operator !=(VideoSessionKHR const & rhs) const5009     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5010     {
5011       return m_videoSessionKHR != rhs.m_videoSessionKHR;
5012     }
5013 
operator <(VideoSessionKHR const & rhs) const5014     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5015     {
5016       return m_videoSessionKHR < rhs.m_videoSessionKHR;
5017     }
5018 #  endif
5019 
operator VkVideoSessionKHR() const5020     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
5021     {
5022       return m_videoSessionKHR;
5023     }
5024 
operator bool() const5025     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5026     {
5027       return m_videoSessionKHR != VK_NULL_HANDLE;
5028     }
5029 
operator !() const5030     bool operator!() const VULKAN_HPP_NOEXCEPT
5031     {
5032       return m_videoSessionKHR == VK_NULL_HANDLE;
5033     }
5034 
5035   private:
5036     VkVideoSessionKHR m_videoSessionKHR = {};
5037   };
5038   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ),
5039                             "handle and wrapper have different size!" );
5040   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::value,
5041                             "VideoSessionKHR is not nothrow_move_constructible!" );
5042 
5043   template <>
5044   struct VULKAN_HPP_DEPRECATED(
5045     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionKHR>
5046   {
5047     using type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5048   };
5049 
5050   template <>
5051   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
5052   {
5053     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5054   };
5055 
5056   template <>
5057   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
5058   {
5059     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5060   };
5061 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5062 
5063   class DeferredOperationKHR
5064   {
5065   public:
5066     using CType      = VkDeferredOperationKHR;
5067     using NativeType = VkDeferredOperationKHR;
5068 
5069     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5070       VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
5071     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5072       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5073 
5074   public:
5075     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR() = default;
DeferredOperationKHR(std::nullptr_t)5076     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)5077     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5078       : m_deferredOperationKHR( deferredOperationKHR )
5079     {}
5080 
5081 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeferredOperationKHR deferredOperationKHR)5082     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5083     {
5084       m_deferredOperationKHR = deferredOperationKHR;
5085       return *this;
5086     }
5087 #endif
5088 
operator =(std::nullptr_t)5089     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5090     {
5091       m_deferredOperationKHR = {};
5092       return *this;
5093     }
5094 
5095 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5096     auto operator<=>( DeferredOperationKHR const & ) const = default;
5097 #else
operator ==(DeferredOperationKHR const & rhs) const5098     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5099     {
5100       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
5101     }
5102 
operator !=(DeferredOperationKHR const & rhs) const5103     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5104     {
5105       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
5106     }
5107 
operator <(DeferredOperationKHR const & rhs) const5108     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5109     {
5110       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
5111     }
5112 #endif
5113 
operator VkDeferredOperationKHR() const5114     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
5115     {
5116       return m_deferredOperationKHR;
5117     }
5118 
operator bool() const5119     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5120     {
5121       return m_deferredOperationKHR != VK_NULL_HANDLE;
5122     }
5123 
operator !() const5124     bool operator!() const VULKAN_HPP_NOEXCEPT
5125     {
5126       return m_deferredOperationKHR == VK_NULL_HANDLE;
5127     }
5128 
5129   private:
5130     VkDeferredOperationKHR m_deferredOperationKHR = {};
5131   };
5132   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ),
5133                             "handle and wrapper have different size!" );
5134   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::value,
5135                             "DeferredOperationKHR is not nothrow_move_constructible!" );
5136 
5137   template <>
5138   struct VULKAN_HPP_DEPRECATED(
5139     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeferredOperationKHR>
5140   {
5141     using type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
5142   };
5143 
5144   template <>
5145   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
5146   {
5147     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
5148   };
5149 
5150   template <>
5151   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
5152   {
5153     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5154   };
5155 
5156 #if defined( VK_USE_PLATFORM_FUCHSIA )
5157   class BufferCollectionFUCHSIA
5158   {
5159   public:
5160     using CType      = VkBufferCollectionFUCHSIA;
5161     using NativeType = VkBufferCollectionFUCHSIA;
5162 
5163     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5164       VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
5165     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5166       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
5167 
5168   public:
5169     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
BufferCollectionFUCHSIA(std::nullptr_t)5170     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5171     VULKAN_HPP_TYPESAFE_EXPLICIT
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)5172       BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5173       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
5174     {}
5175 
5176 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)5177     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5178     {
5179       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
5180       return *this;
5181     }
5182 #  endif
5183 
operator =(std::nullptr_t)5184     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5185     {
5186       m_bufferCollectionFUCHSIA = {};
5187       return *this;
5188     }
5189 
5190 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5191     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
5192 #  else
operator ==(BufferCollectionFUCHSIA const & rhs) const5193     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5194     {
5195       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
5196     }
5197 
operator !=(BufferCollectionFUCHSIA const & rhs) const5198     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5199     {
5200       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
5201     }
5202 
operator <(BufferCollectionFUCHSIA const & rhs) const5203     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5204     {
5205       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
5206     }
5207 #  endif
5208 
operator VkBufferCollectionFUCHSIA() const5209     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
5210     {
5211       return m_bufferCollectionFUCHSIA;
5212     }
5213 
operator bool() const5214     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5215     {
5216       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
5217     }
5218 
operator !() const5219     bool operator!() const VULKAN_HPP_NOEXCEPT
5220     {
5221       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
5222     }
5223 
5224   private:
5225     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
5226   };
5227   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA ) ==
5228                               sizeof( VkBufferCollectionFUCHSIA ),
5229                             "handle and wrapper have different size!" );
5230   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::value,
5231                             "BufferCollectionFUCHSIA is not nothrow_move_constructible!" );
5232 
5233   template <>
5234   struct VULKAN_HPP_DEPRECATED(
5235     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBufferCollectionFUCHSIA>
5236   {
5237     using type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5238   };
5239 
5240   template <>
5241   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
5242   {
5243     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5244   };
5245 
5246   template <>
5247   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5248                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
5249   {
5250     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5251   };
5252 
5253   template <>
5254   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
5255   {
5256     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5257   };
5258 #endif /*VK_USE_PLATFORM_FUCHSIA*/
5259 
5260   class BufferView
5261   {
5262   public:
5263     using CType      = VkBufferView;
5264     using NativeType = VkBufferView;
5265 
5266     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5267       VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
5268     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5269       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
5270 
5271   public:
5272     VULKAN_HPP_CONSTEXPR         BufferView() = default;
BufferView(std::nullptr_t)5273     VULKAN_HPP_CONSTEXPR         BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
BufferView(VkBufferView bufferView)5274     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView )
5275     {}
5276 
5277 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBufferView bufferView)5278     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
5279     {
5280       m_bufferView = bufferView;
5281       return *this;
5282     }
5283 #endif
5284 
operator =(std::nullptr_t)5285     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5286     {
5287       m_bufferView = {};
5288       return *this;
5289     }
5290 
5291 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5292     auto operator<=>( BufferView const & ) const = default;
5293 #else
operator ==(BufferView const & rhs) const5294     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5295     {
5296       return m_bufferView == rhs.m_bufferView;
5297     }
5298 
operator !=(BufferView const & rhs) const5299     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5300     {
5301       return m_bufferView != rhs.m_bufferView;
5302     }
5303 
operator <(BufferView const & rhs) const5304     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5305     {
5306       return m_bufferView < rhs.m_bufferView;
5307     }
5308 #endif
5309 
operator VkBufferView() const5310     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
5311     {
5312       return m_bufferView;
5313     }
5314 
operator bool() const5315     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5316     {
5317       return m_bufferView != VK_NULL_HANDLE;
5318     }
5319 
operator !() const5320     bool operator!() const VULKAN_HPP_NOEXCEPT
5321     {
5322       return m_bufferView == VK_NULL_HANDLE;
5323     }
5324 
5325   private:
5326     VkBufferView m_bufferView = {};
5327   };
5328   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ),
5329                             "handle and wrapper have different size!" );
5330   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferView>::value,
5331                             "BufferView is not nothrow_move_constructible!" );
5332 
5333   template <>
5334   struct VULKAN_HPP_DEPRECATED(
5335     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBufferView>
5336   {
5337     using type = VULKAN_HPP_NAMESPACE::BufferView;
5338   };
5339 
5340   template <>
5341   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
5342   {
5343     using Type = VULKAN_HPP_NAMESPACE::BufferView;
5344   };
5345 
5346   template <>
5347   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5348                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
5349   {
5350     using Type = VULKAN_HPP_NAMESPACE::BufferView;
5351   };
5352 
5353   template <>
5354   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
5355   {
5356     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5357   };
5358 
5359   class CommandPool
5360   {
5361   public:
5362     using CType      = VkCommandPool;
5363     using NativeType = VkCommandPool;
5364 
5365     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5366       VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
5367     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5368       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
5369 
5370   public:
5371     VULKAN_HPP_CONSTEXPR         CommandPool() = default;
CommandPool(std::nullptr_t)5372     VULKAN_HPP_CONSTEXPR         CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CommandPool(VkCommandPool commandPool)5373     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
5374       : m_commandPool( commandPool )
5375     {}
5376 
5377 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandPool commandPool)5378     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
5379     {
5380       m_commandPool = commandPool;
5381       return *this;
5382     }
5383 #endif
5384 
operator =(std::nullptr_t)5385     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5386     {
5387       m_commandPool = {};
5388       return *this;
5389     }
5390 
5391 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5392     auto operator<=>( CommandPool const & ) const = default;
5393 #else
operator ==(CommandPool const & rhs) const5394     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5395     {
5396       return m_commandPool == rhs.m_commandPool;
5397     }
5398 
operator !=(CommandPool const & rhs) const5399     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5400     {
5401       return m_commandPool != rhs.m_commandPool;
5402     }
5403 
operator <(CommandPool const & rhs) const5404     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5405     {
5406       return m_commandPool < rhs.m_commandPool;
5407     }
5408 #endif
5409 
operator VkCommandPool() const5410     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
5411     {
5412       return m_commandPool;
5413     }
5414 
operator bool() const5415     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5416     {
5417       return m_commandPool != VK_NULL_HANDLE;
5418     }
5419 
operator !() const5420     bool operator!() const VULKAN_HPP_NOEXCEPT
5421     {
5422       return m_commandPool == VK_NULL_HANDLE;
5423     }
5424 
5425   private:
5426     VkCommandPool m_commandPool = {};
5427   };
5428   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ),
5429                             "handle and wrapper have different size!" );
5430   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandPool>::value,
5431                             "CommandPool is not nothrow_move_constructible!" );
5432 
5433   template <>
5434   struct VULKAN_HPP_DEPRECATED(
5435     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandPool>
5436   {
5437     using type = VULKAN_HPP_NAMESPACE::CommandPool;
5438   };
5439 
5440   template <>
5441   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
5442   {
5443     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
5444   };
5445 
5446   template <>
5447   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5448                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
5449   {
5450     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
5451   };
5452 
5453   template <>
5454   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
5455   {
5456     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5457   };
5458 
5459   class PipelineCache
5460   {
5461   public:
5462     using CType      = VkPipelineCache;
5463     using NativeType = VkPipelineCache;
5464 
5465     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5466       VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
5467     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5468       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
5469 
5470   public:
5471     VULKAN_HPP_CONSTEXPR         PipelineCache() = default;
PipelineCache(std::nullptr_t)5472     VULKAN_HPP_CONSTEXPR         PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PipelineCache(VkPipelineCache pipelineCache)5473     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
5474       : m_pipelineCache( pipelineCache )
5475     {}
5476 
5477 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineCache pipelineCache)5478     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
5479     {
5480       m_pipelineCache = pipelineCache;
5481       return *this;
5482     }
5483 #endif
5484 
operator =(std::nullptr_t)5485     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5486     {
5487       m_pipelineCache = {};
5488       return *this;
5489     }
5490 
5491 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5492     auto operator<=>( PipelineCache const & ) const = default;
5493 #else
operator ==(PipelineCache const & rhs) const5494     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5495     {
5496       return m_pipelineCache == rhs.m_pipelineCache;
5497     }
5498 
operator !=(PipelineCache const & rhs) const5499     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5500     {
5501       return m_pipelineCache != rhs.m_pipelineCache;
5502     }
5503 
operator <(PipelineCache const & rhs) const5504     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5505     {
5506       return m_pipelineCache < rhs.m_pipelineCache;
5507     }
5508 #endif
5509 
operator VkPipelineCache() const5510     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
5511     {
5512       return m_pipelineCache;
5513     }
5514 
operator bool() const5515     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5516     {
5517       return m_pipelineCache != VK_NULL_HANDLE;
5518     }
5519 
operator !() const5520     bool operator!() const VULKAN_HPP_NOEXCEPT
5521     {
5522       return m_pipelineCache == VK_NULL_HANDLE;
5523     }
5524 
5525   private:
5526     VkPipelineCache m_pipelineCache = {};
5527   };
5528   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ),
5529                             "handle and wrapper have different size!" );
5530   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCache>::value,
5531                             "PipelineCache is not nothrow_move_constructible!" );
5532 
5533   template <>
5534   struct VULKAN_HPP_DEPRECATED(
5535     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineCache>
5536   {
5537     using type = VULKAN_HPP_NAMESPACE::PipelineCache;
5538   };
5539 
5540   template <>
5541   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
5542   {
5543     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5544   };
5545 
5546   template <>
5547   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5548                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
5549   {
5550     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5551   };
5552 
5553   template <>
5554   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
5555   {
5556     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5557   };
5558 
5559   class CuFunctionNVX
5560   {
5561   public:
5562     using CType      = VkCuFunctionNVX;
5563     using NativeType = VkCuFunctionNVX;
5564 
5565     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5566       VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
5567     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5568       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
5569 
5570   public:
5571     VULKAN_HPP_CONSTEXPR         CuFunctionNVX() = default;
CuFunctionNVX(std::nullptr_t)5572     VULKAN_HPP_CONSTEXPR         CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)5573     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5574       : m_cuFunctionNVX( cuFunctionNVX )
5575     {}
5576 
5577 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuFunctionNVX cuFunctionNVX)5578     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5579     {
5580       m_cuFunctionNVX = cuFunctionNVX;
5581       return *this;
5582     }
5583 #endif
5584 
operator =(std::nullptr_t)5585     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5586     {
5587       m_cuFunctionNVX = {};
5588       return *this;
5589     }
5590 
5591 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5592     auto operator<=>( CuFunctionNVX const & ) const = default;
5593 #else
operator ==(CuFunctionNVX const & rhs) const5594     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5595     {
5596       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
5597     }
5598 
operator !=(CuFunctionNVX const & rhs) const5599     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5600     {
5601       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
5602     }
5603 
operator <(CuFunctionNVX const & rhs) const5604     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5605     {
5606       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
5607     }
5608 #endif
5609 
operator VkCuFunctionNVX() const5610     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
5611     {
5612       return m_cuFunctionNVX;
5613     }
5614 
operator bool() const5615     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5616     {
5617       return m_cuFunctionNVX != VK_NULL_HANDLE;
5618     }
5619 
operator !() const5620     bool operator!() const VULKAN_HPP_NOEXCEPT
5621     {
5622       return m_cuFunctionNVX == VK_NULL_HANDLE;
5623     }
5624 
5625   private:
5626     VkCuFunctionNVX m_cuFunctionNVX = {};
5627   };
5628   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ),
5629                             "handle and wrapper have different size!" );
5630   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::value,
5631                             "CuFunctionNVX is not nothrow_move_constructible!" );
5632 
5633   template <>
5634   struct VULKAN_HPP_DEPRECATED(
5635     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuFunctionNVX>
5636   {
5637     using type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5638   };
5639 
5640   template <>
5641   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
5642   {
5643     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5644   };
5645 
5646   template <>
5647   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5648                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
5649   {
5650     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5651   };
5652 
5653   template <>
5654   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
5655   {
5656     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5657   };
5658 
5659   class CuModuleNVX
5660   {
5661   public:
5662     using CType      = VkCuModuleNVX;
5663     using NativeType = VkCuModuleNVX;
5664 
5665     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5666       VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
5667     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5668       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
5669 
5670   public:
5671     VULKAN_HPP_CONSTEXPR         CuModuleNVX() = default;
CuModuleNVX(std::nullptr_t)5672     VULKAN_HPP_CONSTEXPR         CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CuModuleNVX(VkCuModuleNVX cuModuleNVX)5673     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5674       : m_cuModuleNVX( cuModuleNVX )
5675     {}
5676 
5677 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuModuleNVX cuModuleNVX)5678     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5679     {
5680       m_cuModuleNVX = cuModuleNVX;
5681       return *this;
5682     }
5683 #endif
5684 
operator =(std::nullptr_t)5685     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5686     {
5687       m_cuModuleNVX = {};
5688       return *this;
5689     }
5690 
5691 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5692     auto operator<=>( CuModuleNVX const & ) const = default;
5693 #else
operator ==(CuModuleNVX const & rhs) const5694     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5695     {
5696       return m_cuModuleNVX == rhs.m_cuModuleNVX;
5697     }
5698 
operator !=(CuModuleNVX const & rhs) const5699     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5700     {
5701       return m_cuModuleNVX != rhs.m_cuModuleNVX;
5702     }
5703 
operator <(CuModuleNVX const & rhs) const5704     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5705     {
5706       return m_cuModuleNVX < rhs.m_cuModuleNVX;
5707     }
5708 #endif
5709 
operator VkCuModuleNVX() const5710     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
5711     {
5712       return m_cuModuleNVX;
5713     }
5714 
operator bool() const5715     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5716     {
5717       return m_cuModuleNVX != VK_NULL_HANDLE;
5718     }
5719 
operator !() const5720     bool operator!() const VULKAN_HPP_NOEXCEPT
5721     {
5722       return m_cuModuleNVX == VK_NULL_HANDLE;
5723     }
5724 
5725   private:
5726     VkCuModuleNVX m_cuModuleNVX = {};
5727   };
5728   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ),
5729                             "handle and wrapper have different size!" );
5730   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleNVX>::value,
5731                             "CuModuleNVX is not nothrow_move_constructible!" );
5732 
5733   template <>
5734   struct VULKAN_HPP_DEPRECATED(
5735     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuModuleNVX>
5736   {
5737     using type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5738   };
5739 
5740   template <>
5741   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
5742   {
5743     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5744   };
5745 
5746   template <>
5747   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5748                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
5749   {
5750     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5751   };
5752 
5753   template <>
5754   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
5755   {
5756     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5757   };
5758 
5759   class DescriptorPool
5760   {
5761   public:
5762     using CType      = VkDescriptorPool;
5763     using NativeType = VkDescriptorPool;
5764 
5765     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5766       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
5767     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5768       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
5769 
5770   public:
5771     VULKAN_HPP_CONSTEXPR         DescriptorPool() = default;
DescriptorPool(std::nullptr_t)5772     VULKAN_HPP_CONSTEXPR         DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorPool(VkDescriptorPool descriptorPool)5773     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5774       : m_descriptorPool( descriptorPool )
5775     {}
5776 
5777 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorPool descriptorPool)5778     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5779     {
5780       m_descriptorPool = descriptorPool;
5781       return *this;
5782     }
5783 #endif
5784 
operator =(std::nullptr_t)5785     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5786     {
5787       m_descriptorPool = {};
5788       return *this;
5789     }
5790 
5791 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5792     auto operator<=>( DescriptorPool const & ) const = default;
5793 #else
operator ==(DescriptorPool const & rhs) const5794     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5795     {
5796       return m_descriptorPool == rhs.m_descriptorPool;
5797     }
5798 
operator !=(DescriptorPool const & rhs) const5799     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5800     {
5801       return m_descriptorPool != rhs.m_descriptorPool;
5802     }
5803 
operator <(DescriptorPool const & rhs) const5804     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5805     {
5806       return m_descriptorPool < rhs.m_descriptorPool;
5807     }
5808 #endif
5809 
operator VkDescriptorPool() const5810     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
5811     {
5812       return m_descriptorPool;
5813     }
5814 
operator bool() const5815     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5816     {
5817       return m_descriptorPool != VK_NULL_HANDLE;
5818     }
5819 
operator !() const5820     bool operator!() const VULKAN_HPP_NOEXCEPT
5821     {
5822       return m_descriptorPool == VK_NULL_HANDLE;
5823     }
5824 
5825   private:
5826     VkDescriptorPool m_descriptorPool = {};
5827   };
5828   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ),
5829                             "handle and wrapper have different size!" );
5830   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPool>::value,
5831                             "DescriptorPool is not nothrow_move_constructible!" );
5832 
5833   template <>
5834   struct VULKAN_HPP_DEPRECATED(
5835     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorPool>
5836   {
5837     using type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5838   };
5839 
5840   template <>
5841   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
5842   {
5843     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5844   };
5845 
5846   template <>
5847   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5848                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
5849   {
5850     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5851   };
5852 
5853   template <>
5854   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
5855   {
5856     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5857   };
5858 
5859   class DescriptorSetLayout
5860   {
5861   public:
5862     using CType      = VkDescriptorSetLayout;
5863     using NativeType = VkDescriptorSetLayout;
5864 
5865     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5866       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
5867     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5868       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
5869 
5870   public:
5871     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout() = default;
DescriptorSetLayout(std::nullptr_t)5872     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)5873     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5874       : m_descriptorSetLayout( descriptorSetLayout )
5875     {}
5876 
5877 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSetLayout descriptorSetLayout)5878     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5879     {
5880       m_descriptorSetLayout = descriptorSetLayout;
5881       return *this;
5882     }
5883 #endif
5884 
operator =(std::nullptr_t)5885     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5886     {
5887       m_descriptorSetLayout = {};
5888       return *this;
5889     }
5890 
5891 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5892     auto operator<=>( DescriptorSetLayout const & ) const = default;
5893 #else
operator ==(DescriptorSetLayout const & rhs) const5894     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5895     {
5896       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
5897     }
5898 
operator !=(DescriptorSetLayout const & rhs) const5899     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5900     {
5901       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
5902     }
5903 
operator <(DescriptorSetLayout const & rhs) const5904     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5905     {
5906       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
5907     }
5908 #endif
5909 
operator VkDescriptorSetLayout() const5910     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
5911     {
5912       return m_descriptorSetLayout;
5913     }
5914 
operator bool() const5915     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5916     {
5917       return m_descriptorSetLayout != VK_NULL_HANDLE;
5918     }
5919 
operator !() const5920     bool operator!() const VULKAN_HPP_NOEXCEPT
5921     {
5922       return m_descriptorSetLayout == VK_NULL_HANDLE;
5923     }
5924 
5925   private:
5926     VkDescriptorSetLayout m_descriptorSetLayout = {};
5927   };
5928   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ),
5929                             "handle and wrapper have different size!" );
5930   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::value,
5931                             "DescriptorSetLayout is not nothrow_move_constructible!" );
5932 
5933   template <>
5934   struct VULKAN_HPP_DEPRECATED(
5935     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSetLayout>
5936   {
5937     using type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5938   };
5939 
5940   template <>
5941   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
5942   {
5943     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5944   };
5945 
5946   template <>
5947   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5948                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
5949   {
5950     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5951   };
5952 
5953   template <>
5954   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
5955   {
5956     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5957   };
5958 
5959   class Framebuffer
5960   {
5961   public:
5962     using CType      = VkFramebuffer;
5963     using NativeType = VkFramebuffer;
5964 
5965     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5966       VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
5967     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5968       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
5969 
5970   public:
5971     VULKAN_HPP_CONSTEXPR         Framebuffer() = default;
Framebuffer(std::nullptr_t)5972     VULKAN_HPP_CONSTEXPR         Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Framebuffer(VkFramebuffer framebuffer)5973     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
5974       : m_framebuffer( framebuffer )
5975     {}
5976 
5977 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFramebuffer framebuffer)5978     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
5979     {
5980       m_framebuffer = framebuffer;
5981       return *this;
5982     }
5983 #endif
5984 
operator =(std::nullptr_t)5985     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5986     {
5987       m_framebuffer = {};
5988       return *this;
5989     }
5990 
5991 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5992     auto operator<=>( Framebuffer const & ) const = default;
5993 #else
operator ==(Framebuffer const & rhs) const5994     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
5995     {
5996       return m_framebuffer == rhs.m_framebuffer;
5997     }
5998 
operator !=(Framebuffer const & rhs) const5999     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6000     {
6001       return m_framebuffer != rhs.m_framebuffer;
6002     }
6003 
operator <(Framebuffer const & rhs) const6004     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6005     {
6006       return m_framebuffer < rhs.m_framebuffer;
6007     }
6008 #endif
6009 
operator VkFramebuffer() const6010     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
6011     {
6012       return m_framebuffer;
6013     }
6014 
operator bool() const6015     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6016     {
6017       return m_framebuffer != VK_NULL_HANDLE;
6018     }
6019 
operator !() const6020     bool operator!() const VULKAN_HPP_NOEXCEPT
6021     {
6022       return m_framebuffer == VK_NULL_HANDLE;
6023     }
6024 
6025   private:
6026     VkFramebuffer m_framebuffer = {};
6027   };
6028   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ),
6029                             "handle and wrapper have different size!" );
6030   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Framebuffer>::value,
6031                             "Framebuffer is not nothrow_move_constructible!" );
6032 
6033   template <>
6034   struct VULKAN_HPP_DEPRECATED(
6035     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFramebuffer>
6036   {
6037     using type = VULKAN_HPP_NAMESPACE::Framebuffer;
6038   };
6039 
6040   template <>
6041   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
6042   {
6043     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6044   };
6045 
6046   template <>
6047   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6048                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
6049   {
6050     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6051   };
6052 
6053   template <>
6054   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
6055   {
6056     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6057   };
6058 
6059   class IndirectCommandsLayoutNV
6060   {
6061   public:
6062     using CType      = VkIndirectCommandsLayoutNV;
6063     using NativeType = VkIndirectCommandsLayoutNV;
6064 
6065     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6066       VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
6067     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6068       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6069 
6070   public:
6071     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
IndirectCommandsLayoutNV(std::nullptr_t)6072     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6073     VULKAN_HPP_TYPESAFE_EXPLICIT
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6074       IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6075       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
6076     {}
6077 
6078 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6079     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6080     {
6081       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
6082       return *this;
6083     }
6084 #endif
6085 
operator =(std::nullptr_t)6086     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6087     {
6088       m_indirectCommandsLayoutNV = {};
6089       return *this;
6090     }
6091 
6092 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6093     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
6094 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const6095     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6096     {
6097       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
6098     }
6099 
operator !=(IndirectCommandsLayoutNV const & rhs) const6100     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6101     {
6102       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
6103     }
6104 
operator <(IndirectCommandsLayoutNV const & rhs) const6105     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6106     {
6107       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
6108     }
6109 #endif
6110 
operator VkIndirectCommandsLayoutNV() const6111     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
6112     {
6113       return m_indirectCommandsLayoutNV;
6114     }
6115 
operator bool() const6116     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6117     {
6118       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
6119     }
6120 
operator !() const6121     bool operator!() const VULKAN_HPP_NOEXCEPT
6122     {
6123       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
6124     }
6125 
6126   private:
6127     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
6128   };
6129   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) ==
6130                               sizeof( VkIndirectCommandsLayoutNV ),
6131                             "handle and wrapper have different size!" );
6132   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::value,
6133                             "IndirectCommandsLayoutNV is not nothrow_move_constructible!" );
6134 
6135   template <>
6136   struct VULKAN_HPP_DEPRECATED(
6137     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eIndirectCommandsLayoutNV>
6138   {
6139     using type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
6140   };
6141 
6142   template <>
6143   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
6144   {
6145     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
6146   };
6147 
6148   template <>
6149   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
6150   {
6151     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6152   };
6153 
6154   class PrivateDataSlotEXT
6155   {
6156   public:
6157     using CType      = VkPrivateDataSlotEXT;
6158     using NativeType = VkPrivateDataSlotEXT;
6159 
6160     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6161       VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT;
6162     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6163       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6164 
6165   public:
6166     VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT() = default;
PrivateDataSlotEXT(std::nullptr_t)6167     VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PrivateDataSlotEXT(VkPrivateDataSlotEXT privateDataSlotEXT)6168     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlotEXT( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
6169       : m_privateDataSlotEXT( privateDataSlotEXT )
6170     {}
6171 
6172 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPrivateDataSlotEXT privateDataSlotEXT)6173     PrivateDataSlotEXT & operator=( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
6174     {
6175       m_privateDataSlotEXT = privateDataSlotEXT;
6176       return *this;
6177     }
6178 #endif
6179 
operator =(std::nullptr_t)6180     PrivateDataSlotEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6181     {
6182       m_privateDataSlotEXT = {};
6183       return *this;
6184     }
6185 
6186 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6187     auto operator<=>( PrivateDataSlotEXT const & ) const = default;
6188 #else
operator ==(PrivateDataSlotEXT const & rhs) const6189     bool operator==( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6190     {
6191       return m_privateDataSlotEXT == rhs.m_privateDataSlotEXT;
6192     }
6193 
operator !=(PrivateDataSlotEXT const & rhs) const6194     bool operator!=( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6195     {
6196       return m_privateDataSlotEXT != rhs.m_privateDataSlotEXT;
6197     }
6198 
operator <(PrivateDataSlotEXT const & rhs) const6199     bool operator<( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6200     {
6201       return m_privateDataSlotEXT < rhs.m_privateDataSlotEXT;
6202     }
6203 #endif
6204 
operator VkPrivateDataSlotEXT() const6205     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlotEXT() const VULKAN_HPP_NOEXCEPT
6206     {
6207       return m_privateDataSlotEXT;
6208     }
6209 
operator bool() const6210     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6211     {
6212       return m_privateDataSlotEXT != VK_NULL_HANDLE;
6213     }
6214 
operator !() const6215     bool operator!() const VULKAN_HPP_NOEXCEPT
6216     {
6217       return m_privateDataSlotEXT == VK_NULL_HANDLE;
6218     }
6219 
6220   private:
6221     VkPrivateDataSlotEXT m_privateDataSlotEXT = {};
6222   };
6223   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ),
6224                             "handle and wrapper have different size!" );
6225   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::value,
6226                             "PrivateDataSlotEXT is not nothrow_move_constructible!" );
6227 
6228   template <>
6229   struct VULKAN_HPP_DEPRECATED(
6230     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePrivateDataSlotEXT>
6231   {
6232     using type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
6233   };
6234 
6235   template <>
6236   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT>
6237   {
6238     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
6239   };
6240 
6241   template <>
6242   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
6243   {
6244     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6245   };
6246 
6247   class RenderPass
6248   {
6249   public:
6250     using CType      = VkRenderPass;
6251     using NativeType = VkRenderPass;
6252 
6253     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6254       VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
6255     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6256       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
6257 
6258   public:
6259     VULKAN_HPP_CONSTEXPR         RenderPass() = default;
RenderPass(std::nullptr_t)6260     VULKAN_HPP_CONSTEXPR         RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
RenderPass(VkRenderPass renderPass)6261     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass )
6262     {}
6263 
6264 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkRenderPass renderPass)6265     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
6266     {
6267       m_renderPass = renderPass;
6268       return *this;
6269     }
6270 #endif
6271 
operator =(std::nullptr_t)6272     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6273     {
6274       m_renderPass = {};
6275       return *this;
6276     }
6277 
6278 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6279     auto operator<=>( RenderPass const & ) const = default;
6280 #else
operator ==(RenderPass const & rhs) const6281     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6282     {
6283       return m_renderPass == rhs.m_renderPass;
6284     }
6285 
operator !=(RenderPass const & rhs) const6286     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6287     {
6288       return m_renderPass != rhs.m_renderPass;
6289     }
6290 
operator <(RenderPass const & rhs) const6291     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6292     {
6293       return m_renderPass < rhs.m_renderPass;
6294     }
6295 #endif
6296 
operator VkRenderPass() const6297     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
6298     {
6299       return m_renderPass;
6300     }
6301 
operator bool() const6302     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6303     {
6304       return m_renderPass != VK_NULL_HANDLE;
6305     }
6306 
operator !() const6307     bool operator!() const VULKAN_HPP_NOEXCEPT
6308     {
6309       return m_renderPass == VK_NULL_HANDLE;
6310     }
6311 
6312   private:
6313     VkRenderPass m_renderPass = {};
6314   };
6315   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ),
6316                             "handle and wrapper have different size!" );
6317   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPass>::value,
6318                             "RenderPass is not nothrow_move_constructible!" );
6319 
6320   template <>
6321   struct VULKAN_HPP_DEPRECATED(
6322     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eRenderPass>
6323   {
6324     using type = VULKAN_HPP_NAMESPACE::RenderPass;
6325   };
6326 
6327   template <>
6328   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
6329   {
6330     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
6331   };
6332 
6333   template <>
6334   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6335                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
6336   {
6337     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
6338   };
6339 
6340   template <>
6341   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
6342   {
6343     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6344   };
6345 
6346   class Sampler
6347   {
6348   public:
6349     using CType      = VkSampler;
6350     using NativeType = VkSampler;
6351 
6352     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6353       VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
6354     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6355       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
6356 
6357   public:
6358     VULKAN_HPP_CONSTEXPR         Sampler() = default;
Sampler(std::nullptr_t)6359     VULKAN_HPP_CONSTEXPR         Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Sampler(VkSampler sampler)6360     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
6361 
6362 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSampler sampler)6363     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
6364     {
6365       m_sampler = sampler;
6366       return *this;
6367     }
6368 #endif
6369 
operator =(std::nullptr_t)6370     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6371     {
6372       m_sampler = {};
6373       return *this;
6374     }
6375 
6376 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6377     auto operator<=>( Sampler const & ) const = default;
6378 #else
operator ==(Sampler const & rhs) const6379     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6380     {
6381       return m_sampler == rhs.m_sampler;
6382     }
6383 
operator !=(Sampler const & rhs) const6384     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6385     {
6386       return m_sampler != rhs.m_sampler;
6387     }
6388 
operator <(Sampler const & rhs) const6389     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6390     {
6391       return m_sampler < rhs.m_sampler;
6392     }
6393 #endif
6394 
operator VkSampler() const6395     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
6396     {
6397       return m_sampler;
6398     }
6399 
operator bool() const6400     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6401     {
6402       return m_sampler != VK_NULL_HANDLE;
6403     }
6404 
operator !() const6405     bool operator!() const VULKAN_HPP_NOEXCEPT
6406     {
6407       return m_sampler == VK_NULL_HANDLE;
6408     }
6409 
6410   private:
6411     VkSampler m_sampler = {};
6412   };
6413   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ),
6414                             "handle and wrapper have different size!" );
6415   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Sampler>::value,
6416                             "Sampler is not nothrow_move_constructible!" );
6417 
6418   template <>
6419   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSampler>
6420   {
6421     using type = VULKAN_HPP_NAMESPACE::Sampler;
6422   };
6423 
6424   template <>
6425   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
6426   {
6427     using Type = VULKAN_HPP_NAMESPACE::Sampler;
6428   };
6429 
6430   template <>
6431   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6432                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
6433   {
6434     using Type = VULKAN_HPP_NAMESPACE::Sampler;
6435   };
6436 
6437   template <>
6438   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
6439   {
6440     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6441   };
6442 
6443   class SamplerYcbcrConversion
6444   {
6445   public:
6446     using CType      = VkSamplerYcbcrConversion;
6447     using NativeType = VkSamplerYcbcrConversion;
6448 
6449     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6450       VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
6451     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6452       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
6453 
6454   public:
6455     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
SamplerYcbcrConversion(std::nullptr_t)6456     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6457     VULKAN_HPP_TYPESAFE_EXPLICIT
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)6458       SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6459       : m_samplerYcbcrConversion( samplerYcbcrConversion )
6460     {}
6461 
6462 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)6463     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6464     {
6465       m_samplerYcbcrConversion = samplerYcbcrConversion;
6466       return *this;
6467     }
6468 #endif
6469 
operator =(std::nullptr_t)6470     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6471     {
6472       m_samplerYcbcrConversion = {};
6473       return *this;
6474     }
6475 
6476 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6477     auto operator<=>( SamplerYcbcrConversion const & ) const = default;
6478 #else
operator ==(SamplerYcbcrConversion const & rhs) const6479     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6480     {
6481       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
6482     }
6483 
operator !=(SamplerYcbcrConversion const & rhs) const6484     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6485     {
6486       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
6487     }
6488 
operator <(SamplerYcbcrConversion const & rhs) const6489     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6490     {
6491       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
6492     }
6493 #endif
6494 
operator VkSamplerYcbcrConversion() const6495     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
6496     {
6497       return m_samplerYcbcrConversion;
6498     }
6499 
operator bool() const6500     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6501     {
6502       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
6503     }
6504 
operator !() const6505     bool operator!() const VULKAN_HPP_NOEXCEPT
6506     {
6507       return m_samplerYcbcrConversion == VK_NULL_HANDLE;
6508     }
6509 
6510   private:
6511     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
6512   };
6513   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) ==
6514                               sizeof( VkSamplerYcbcrConversion ),
6515                             "handle and wrapper have different size!" );
6516   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::value,
6517                             "SamplerYcbcrConversion is not nothrow_move_constructible!" );
6518 
6519   template <>
6520   struct VULKAN_HPP_DEPRECATED(
6521     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSamplerYcbcrConversion>
6522   {
6523     using type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6524   };
6525 
6526   template <>
6527   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
6528   {
6529     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6530   };
6531 
6532   template <>
6533   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6534                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
6535   {
6536     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6537   };
6538 
6539   template <>
6540   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
6541   {
6542     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6543   };
6544   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
6545 
6546   class ShaderModule
6547   {
6548   public:
6549     using CType      = VkShaderModule;
6550     using NativeType = VkShaderModule;
6551 
6552     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6553       VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
6554     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6555       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
6556 
6557   public:
6558     VULKAN_HPP_CONSTEXPR         ShaderModule() = default;
ShaderModule(std::nullptr_t)6559     VULKAN_HPP_CONSTEXPR         ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ShaderModule(VkShaderModule shaderModule)6560     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6561       : m_shaderModule( shaderModule )
6562     {}
6563 
6564 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkShaderModule shaderModule)6565     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6566     {
6567       m_shaderModule = shaderModule;
6568       return *this;
6569     }
6570 #endif
6571 
operator =(std::nullptr_t)6572     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6573     {
6574       m_shaderModule = {};
6575       return *this;
6576     }
6577 
6578 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6579     auto operator<=>( ShaderModule const & ) const = default;
6580 #else
operator ==(ShaderModule const & rhs) const6581     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6582     {
6583       return m_shaderModule == rhs.m_shaderModule;
6584     }
6585 
operator !=(ShaderModule const & rhs) const6586     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6587     {
6588       return m_shaderModule != rhs.m_shaderModule;
6589     }
6590 
operator <(ShaderModule const & rhs) const6591     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6592     {
6593       return m_shaderModule < rhs.m_shaderModule;
6594     }
6595 #endif
6596 
operator VkShaderModule() const6597     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
6598     {
6599       return m_shaderModule;
6600     }
6601 
operator bool() const6602     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6603     {
6604       return m_shaderModule != VK_NULL_HANDLE;
6605     }
6606 
operator !() const6607     bool operator!() const VULKAN_HPP_NOEXCEPT
6608     {
6609       return m_shaderModule == VK_NULL_HANDLE;
6610     }
6611 
6612   private:
6613     VkShaderModule m_shaderModule = {};
6614   };
6615   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ),
6616                             "handle and wrapper have different size!" );
6617   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderModule>::value,
6618                             "ShaderModule is not nothrow_move_constructible!" );
6619 
6620   template <>
6621   struct VULKAN_HPP_DEPRECATED(
6622     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eShaderModule>
6623   {
6624     using type = VULKAN_HPP_NAMESPACE::ShaderModule;
6625   };
6626 
6627   template <>
6628   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
6629   {
6630     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6631   };
6632 
6633   template <>
6634   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6635                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
6636   {
6637     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6638   };
6639 
6640   template <>
6641   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
6642   {
6643     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6644   };
6645 
6646   class ValidationCacheEXT
6647   {
6648   public:
6649     using CType      = VkValidationCacheEXT;
6650     using NativeType = VkValidationCacheEXT;
6651 
6652     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6653       VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
6654     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6655       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
6656 
6657   public:
6658     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT() = default;
ValidationCacheEXT(std::nullptr_t)6659     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)6660     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6661       : m_validationCacheEXT( validationCacheEXT )
6662     {}
6663 
6664 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkValidationCacheEXT validationCacheEXT)6665     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6666     {
6667       m_validationCacheEXT = validationCacheEXT;
6668       return *this;
6669     }
6670 #endif
6671 
operator =(std::nullptr_t)6672     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6673     {
6674       m_validationCacheEXT = {};
6675       return *this;
6676     }
6677 
6678 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6679     auto operator<=>( ValidationCacheEXT const & ) const = default;
6680 #else
operator ==(ValidationCacheEXT const & rhs) const6681     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6682     {
6683       return m_validationCacheEXT == rhs.m_validationCacheEXT;
6684     }
6685 
operator !=(ValidationCacheEXT const & rhs) const6686     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6687     {
6688       return m_validationCacheEXT != rhs.m_validationCacheEXT;
6689     }
6690 
operator <(ValidationCacheEXT const & rhs) const6691     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6692     {
6693       return m_validationCacheEXT < rhs.m_validationCacheEXT;
6694     }
6695 #endif
6696 
operator VkValidationCacheEXT() const6697     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
6698     {
6699       return m_validationCacheEXT;
6700     }
6701 
operator bool() const6702     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6703     {
6704       return m_validationCacheEXT != VK_NULL_HANDLE;
6705     }
6706 
operator !() const6707     bool operator!() const VULKAN_HPP_NOEXCEPT
6708     {
6709       return m_validationCacheEXT == VK_NULL_HANDLE;
6710     }
6711 
6712   private:
6713     VkValidationCacheEXT m_validationCacheEXT = {};
6714   };
6715   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ),
6716                             "handle and wrapper have different size!" );
6717   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::value,
6718                             "ValidationCacheEXT is not nothrow_move_constructible!" );
6719 
6720   template <>
6721   struct VULKAN_HPP_DEPRECATED(
6722     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eValidationCacheEXT>
6723   {
6724     using type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6725   };
6726 
6727   template <>
6728   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
6729   {
6730     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6731   };
6732 
6733   template <>
6734   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6735                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
6736   {
6737     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6738   };
6739 
6740   template <>
6741   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
6742   {
6743     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6744   };
6745 
6746 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6747   class VideoSessionParametersKHR
6748   {
6749   public:
6750     using CType      = VkVideoSessionParametersKHR;
6751     using NativeType = VkVideoSessionParametersKHR;
6752 
6753     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6754       VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
6755     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6756       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6757 
6758   public:
6759     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
VideoSessionParametersKHR(std::nullptr_t)6760     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6761     VULKAN_HPP_TYPESAFE_EXPLICIT
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)6762       VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6763       : m_videoSessionParametersKHR( videoSessionParametersKHR )
6764     {}
6765 
6766 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)6767     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6768     {
6769       m_videoSessionParametersKHR = videoSessionParametersKHR;
6770       return *this;
6771     }
6772 #  endif
6773 
operator =(std::nullptr_t)6774     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6775     {
6776       m_videoSessionParametersKHR = {};
6777       return *this;
6778     }
6779 
6780 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6781     auto operator<=>( VideoSessionParametersKHR const & ) const = default;
6782 #  else
operator ==(VideoSessionParametersKHR const & rhs) const6783     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6784     {
6785       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
6786     }
6787 
operator !=(VideoSessionParametersKHR const & rhs) const6788     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6789     {
6790       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
6791     }
6792 
operator <(VideoSessionParametersKHR const & rhs) const6793     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6794     {
6795       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
6796     }
6797 #  endif
6798 
operator VkVideoSessionParametersKHR() const6799     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
6800     {
6801       return m_videoSessionParametersKHR;
6802     }
6803 
operator bool() const6804     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6805     {
6806       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
6807     }
6808 
operator !() const6809     bool operator!() const VULKAN_HPP_NOEXCEPT
6810     {
6811       return m_videoSessionParametersKHR == VK_NULL_HANDLE;
6812     }
6813 
6814   private:
6815     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
6816   };
6817   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) ==
6818                               sizeof( VkVideoSessionParametersKHR ),
6819                             "handle and wrapper have different size!" );
6820   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::value,
6821                             "VideoSessionParametersKHR is not nothrow_move_constructible!" );
6822 
6823   template <>
6824   struct VULKAN_HPP_DEPRECATED(
6825     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionParametersKHR>
6826   {
6827     using type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6828   };
6829 
6830   template <>
6831   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
6832   {
6833     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6834   };
6835 
6836   template <>
6837   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
6838   {
6839     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6840   };
6841 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
6842 
6843   class Queue
6844   {
6845   public:
6846     using CType      = VkQueue;
6847     using NativeType = VkQueue;
6848 
6849     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6850       VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
6851     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6852       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
6853 
6854   public:
6855     VULKAN_HPP_CONSTEXPR         Queue() = default;
Queue(std::nullptr_t)6856     VULKAN_HPP_CONSTEXPR         Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Queue(VkQueue queue)6857     VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
6858 
6859 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueue queue)6860     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
6861     {
6862       m_queue = queue;
6863       return *this;
6864     }
6865 #endif
6866 
operator =(std::nullptr_t)6867     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6868     {
6869       m_queue = {};
6870       return *this;
6871     }
6872 
6873 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6874     auto operator<=>( Queue const & ) const = default;
6875 #else
operator ==(Queue const & rhs) const6876     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6877     {
6878       return m_queue == rhs.m_queue;
6879     }
6880 
operator !=(Queue const & rhs) const6881     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6882     {
6883       return m_queue != rhs.m_queue;
6884     }
6885 
operator <(Queue const & rhs) const6886     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6887     {
6888       return m_queue < rhs.m_queue;
6889     }
6890 #endif
6891 
6892     //=== VK_VERSION_1_0 ===
6893 
6894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6895     VULKAN_HPP_NODISCARD Result
6896       submit( uint32_t                                 submitCount,
6897               const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
6898               VULKAN_HPP_NAMESPACE::Fence              fence,
6899               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6900 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6902     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6903       submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
6904               VULKAN_HPP_NAMESPACE::Fence fence                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6905               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6906 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6907 
6908 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6909     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6910     VULKAN_HPP_NODISCARD Result
6911       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6912 #else
6913     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6914     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6915       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6916 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6917 
6918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6919     VULKAN_HPP_NODISCARD Result
6920       bindSparse( uint32_t                                     bindInfoCount,
6921                   const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
6922                   VULKAN_HPP_NAMESPACE::Fence                  fence,
6923                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6925     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6926     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6927       bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
6928                   VULKAN_HPP_NAMESPACE::Fence fence                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6929                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6930 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6931 
6932     //=== VK_KHR_swapchain ===
6933 
6934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6935     VULKAN_HPP_NODISCARD Result
6936       presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
6937                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6939     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6940     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,
6941                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6942 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6943 
6944     //=== VK_EXT_debug_utils ===
6945 
6946     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6947     void
6948       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
6949                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6952     void
6953       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
6954                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6955 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6956 
6957     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6958     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6959 
6960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6961     void
6962       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
6963                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6966     void
6967       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
6968                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6969 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6970 
6971     //=== VK_NV_device_diagnostic_checkpoints ===
6972 
6973     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6974     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
6975                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
6976                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6977 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6978     template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
6979               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6980     VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
6981                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6982     template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
6983               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
6984               typename B                         = CheckpointDataNVAllocator,
6985               typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
6986     VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
6987                          getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator,
6988                                               Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6989 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6990 
6991     //=== VK_INTEL_performance_query ===
6992 
6993 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6994     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6995     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL(
6996       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
6997       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6998 #else
6999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7000     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7001          setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
7002                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7003 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7004 
7005     //=== VK_KHR_synchronization2 ===
7006 
7007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7008     VULKAN_HPP_NODISCARD Result
7009       submit2KHR( uint32_t                                     submitCount,
7010                   const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits,
7011                   VULKAN_HPP_NAMESPACE::Fence                  fence,
7012                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7015     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7016       submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
7017                   VULKAN_HPP_NAMESPACE::Fence fence                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7018                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7019 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7020 
7021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7022     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
7023                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
7024                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7026     template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
7027               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7028     VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
7029                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7030     template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
7031               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7032               typename B                          = CheckpointData2NVAllocator,
7033               typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type = 0>
7034     VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
7035                          getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator,
7036                                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7037 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7038 
operator VkQueue() const7039     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const VULKAN_HPP_NOEXCEPT
7040     {
7041       return m_queue;
7042     }
7043 
operator bool() const7044     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7045     {
7046       return m_queue != VK_NULL_HANDLE;
7047     }
7048 
operator !() const7049     bool operator!() const VULKAN_HPP_NOEXCEPT
7050     {
7051       return m_queue == VK_NULL_HANDLE;
7052     }
7053 
7054   private:
7055     VkQueue m_queue = {};
7056   };
7057   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ),
7058                             "handle and wrapper have different size!" );
7059   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Queue>::value,
7060                             "Queue is not nothrow_move_constructible!" );
7061 
7062   template <>
7063   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueue>
7064   {
7065     using type = VULKAN_HPP_NAMESPACE::Queue;
7066   };
7067 
7068   template <>
7069   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
7070   {
7071     using Type = VULKAN_HPP_NAMESPACE::Queue;
7072   };
7073 
7074   template <>
7075   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
7076   {
7077     using Type = VULKAN_HPP_NAMESPACE::Queue;
7078   };
7079 
7080   template <>
7081   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
7082   {
7083     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7084   };
7085 
7086 #ifndef VULKAN_HPP_NO_SMART_HANDLE
7087   class Device;
7088   template <typename Dispatch>
7089   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
7090   {
7091   public:
7092     using deleter = ObjectDestroy<Device, Dispatch>;
7093   };
7094   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7095   template <typename Dispatch>
7096   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
7097   {
7098   public:
7099     using deleter = ObjectDestroy<Device, Dispatch>;
7100   };
7101   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7102   template <typename Dispatch>
7103   class UniqueHandleTraits<Buffer, Dispatch>
7104   {
7105   public:
7106     using deleter = ObjectDestroy<Device, Dispatch>;
7107   };
7108   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7109 #  if defined( VK_USE_PLATFORM_FUCHSIA )
7110   template <typename Dispatch>
7111   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
7112   {
7113   public:
7114     using deleter = ObjectDestroy<Device, Dispatch>;
7115   };
7116   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7117 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
7118   template <typename Dispatch>
7119   class UniqueHandleTraits<BufferView, Dispatch>
7120   {
7121   public:
7122     using deleter = ObjectDestroy<Device, Dispatch>;
7123   };
7124   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7125   template <typename Dispatch>
7126   class UniqueHandleTraits<CommandBuffer, Dispatch>
7127   {
7128   public:
7129     using deleter = PoolFree<Device, CommandPool, Dispatch>;
7130   };
7131   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7132   template <typename Dispatch>
7133   class UniqueHandleTraits<CommandPool, Dispatch>
7134   {
7135   public:
7136     using deleter = ObjectDestroy<Device, Dispatch>;
7137   };
7138   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7139   template <typename Dispatch>
7140   class UniqueHandleTraits<CuFunctionNVX, Dispatch>
7141   {
7142   public:
7143     using deleter = ObjectDestroy<Device, Dispatch>;
7144   };
7145   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7146   template <typename Dispatch>
7147   class UniqueHandleTraits<CuModuleNVX, Dispatch>
7148   {
7149   public:
7150     using deleter = ObjectDestroy<Device, Dispatch>;
7151   };
7152   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7153   template <typename Dispatch>
7154   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
7155   {
7156   public:
7157     using deleter = ObjectDestroy<Device, Dispatch>;
7158   };
7159   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7160   template <typename Dispatch>
7161   class UniqueHandleTraits<DescriptorPool, Dispatch>
7162   {
7163   public:
7164     using deleter = ObjectDestroy<Device, Dispatch>;
7165   };
7166   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7167   template <typename Dispatch>
7168   class UniqueHandleTraits<DescriptorSet, Dispatch>
7169   {
7170   public:
7171     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
7172   };
7173   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7174   template <typename Dispatch>
7175   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
7176   {
7177   public:
7178     using deleter = ObjectDestroy<Device, Dispatch>;
7179   };
7180   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7181   template <typename Dispatch>
7182   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
7183   {
7184   public:
7185     using deleter = ObjectDestroy<Device, Dispatch>;
7186   };
7187   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7188   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7189   template <typename Dispatch>
7190   class UniqueHandleTraits<DeviceMemory, Dispatch>
7191   {
7192   public:
7193     using deleter = ObjectFree<Device, Dispatch>;
7194   };
7195   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7196   template <typename Dispatch>
7197   class UniqueHandleTraits<Event, Dispatch>
7198   {
7199   public:
7200     using deleter = ObjectDestroy<Device, Dispatch>;
7201   };
7202   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7203   template <typename Dispatch>
7204   class UniqueHandleTraits<Fence, Dispatch>
7205   {
7206   public:
7207     using deleter = ObjectDestroy<Device, Dispatch>;
7208   };
7209   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7210   template <typename Dispatch>
7211   class UniqueHandleTraits<Framebuffer, Dispatch>
7212   {
7213   public:
7214     using deleter = ObjectDestroy<Device, Dispatch>;
7215   };
7216   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7217   template <typename Dispatch>
7218   class UniqueHandleTraits<Image, Dispatch>
7219   {
7220   public:
7221     using deleter = ObjectDestroy<Device, Dispatch>;
7222   };
7223   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7224   template <typename Dispatch>
7225   class UniqueHandleTraits<ImageView, Dispatch>
7226   {
7227   public:
7228     using deleter = ObjectDestroy<Device, Dispatch>;
7229   };
7230   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7231   template <typename Dispatch>
7232   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
7233   {
7234   public:
7235     using deleter = ObjectDestroy<Device, Dispatch>;
7236   };
7237   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7238   template <typename Dispatch>
7239   class UniqueHandleTraits<Pipeline, Dispatch>
7240   {
7241   public:
7242     using deleter = ObjectDestroy<Device, Dispatch>;
7243   };
7244   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7245   template <typename Dispatch>
7246   class UniqueHandleTraits<PipelineCache, Dispatch>
7247   {
7248   public:
7249     using deleter = ObjectDestroy<Device, Dispatch>;
7250   };
7251   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7252   template <typename Dispatch>
7253   class UniqueHandleTraits<PipelineLayout, Dispatch>
7254   {
7255   public:
7256     using deleter = ObjectDestroy<Device, Dispatch>;
7257   };
7258   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7259   template <typename Dispatch>
7260   class UniqueHandleTraits<PrivateDataSlotEXT, Dispatch>
7261   {
7262   public:
7263     using deleter = ObjectDestroy<Device, Dispatch>;
7264   };
7265   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlotEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7266   template <typename Dispatch>
7267   class UniqueHandleTraits<QueryPool, Dispatch>
7268   {
7269   public:
7270     using deleter = ObjectDestroy<Device, Dispatch>;
7271   };
7272   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7273   template <typename Dispatch>
7274   class UniqueHandleTraits<RenderPass, Dispatch>
7275   {
7276   public:
7277     using deleter = ObjectDestroy<Device, Dispatch>;
7278   };
7279   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7280   template <typename Dispatch>
7281   class UniqueHandleTraits<Sampler, Dispatch>
7282   {
7283   public:
7284     using deleter = ObjectDestroy<Device, Dispatch>;
7285   };
7286   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7287   template <typename Dispatch>
7288   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
7289   {
7290   public:
7291     using deleter = ObjectDestroy<Device, Dispatch>;
7292   };
7293   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7294   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7295   template <typename Dispatch>
7296   class UniqueHandleTraits<Semaphore, Dispatch>
7297   {
7298   public:
7299     using deleter = ObjectDestroy<Device, Dispatch>;
7300   };
7301   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7302   template <typename Dispatch>
7303   class UniqueHandleTraits<ShaderModule, Dispatch>
7304   {
7305   public:
7306     using deleter = ObjectDestroy<Device, Dispatch>;
7307   };
7308   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7309   template <typename Dispatch>
7310   class UniqueHandleTraits<SwapchainKHR, Dispatch>
7311   {
7312   public:
7313     using deleter = ObjectDestroy<Device, Dispatch>;
7314   };
7315   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7316   template <typename Dispatch>
7317   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
7318   {
7319   public:
7320     using deleter = ObjectDestroy<Device, Dispatch>;
7321   };
7322   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7323 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
7324   template <typename Dispatch>
7325   class UniqueHandleTraits<VideoSessionKHR, Dispatch>
7326   {
7327   public:
7328     using deleter = ObjectDestroy<Device, Dispatch>;
7329   };
7330   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7331 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
7332 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
7333   template <typename Dispatch>
7334   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
7335   {
7336   public:
7337     using deleter = ObjectDestroy<Device, Dispatch>;
7338   };
7339   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7340 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
7341 #endif   /*VULKAN_HPP_NO_SMART_HANDLE*/
7342 
7343   class Device
7344   {
7345   public:
7346     using CType      = VkDevice;
7347     using NativeType = VkDevice;
7348 
7349     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
7350       VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
7351     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7352       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
7353 
7354   public:
7355     VULKAN_HPP_CONSTEXPR         Device() = default;
Device(std::nullptr_t)7356     VULKAN_HPP_CONSTEXPR         Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Device(VkDevice device)7357     VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
7358 
7359 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDevice device)7360     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
7361     {
7362       m_device = device;
7363       return *this;
7364     }
7365 #endif
7366 
operator =(std::nullptr_t)7367     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7368     {
7369       m_device = {};
7370       return *this;
7371     }
7372 
7373 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7374     auto operator<=>( Device const & ) const = default;
7375 #else
operator ==(Device const & rhs) const7376     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7377     {
7378       return m_device == rhs.m_device;
7379     }
7380 
operator !=(Device const & rhs) const7381     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7382     {
7383       return m_device != rhs.m_device;
7384     }
7385 
operator <(Device const & rhs) const7386     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7387     {
7388       return m_device < rhs.m_device;
7389     }
7390 #endif
7391 
7392     //=== VK_VERSION_1_0 ===
7393 
7394     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7395     PFN_vkVoidFunction
7396       getProcAddr( const char *       pName,
7397                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7398 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7400     PFN_vkVoidFunction
7401       getProcAddr( const std::string & name,
7402                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7403 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7404 
7405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7406     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7407                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7410     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7411                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7412                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7413 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7414 
7415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7416     void getQueue( uint32_t                      queueFamilyIndex,
7417                    uint32_t                      queueIndex,
7418                    VULKAN_HPP_NAMESPACE::Queue * pQueue,
7419                    Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7421     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7422     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
7423                          getQueue( uint32_t           queueFamilyIndex,
7424                                    uint32_t           queueIndex,
7425                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7426 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7427 
7428 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7429     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7430     VULKAN_HPP_NODISCARD Result
7431       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7432 #else
7433     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7434     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7435       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7436 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7437 
7438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7439     VULKAN_HPP_NODISCARD Result
7440       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
7441                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7442                       VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,
7443                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7444 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7446     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
7447       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo,
7448                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7449                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7450                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7451 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7453     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7454       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
7455       allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo,
7456                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7457                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7458                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7459 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7460 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7461 
7462     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7463     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
7464                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7465                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7466 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7467     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7468     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7469                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7470                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7471                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7472 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7473 
7474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7475     void free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
7476                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7477                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7480     void free( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7481                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7482                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7483                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7484 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7485 
7486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7487     VULKAN_HPP_NODISCARD Result
7488       mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
7489                  VULKAN_HPP_NAMESPACE::DeviceSize     offset,
7490                  VULKAN_HPP_NAMESPACE::DeviceSize     size,
7491                  VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
7492                  void **                              ppData,
7493                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7495     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7496     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void *>::type
7497       mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
7498                  VULKAN_HPP_NAMESPACE::DeviceSize           offset,
7499                  VULKAN_HPP_NAMESPACE::DeviceSize           size,
7500                  VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7501                  Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7502 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7503 
7504     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7505     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7506                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7507 
7508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7509     VULKAN_HPP_NODISCARD Result
7510       flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
7511                                const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
7512                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7515     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7516       flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
7517                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7518 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7519 
7520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7521     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(
7522       uint32_t                                        memoryRangeCount,
7523       const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
7524       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7525 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7527     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7528       invalidateMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
7529                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7530 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7531 
7532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7533     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7534                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
7535                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7538     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
7539                          getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7540                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7541 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7542 
7543 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7544     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7545     VULKAN_HPP_NODISCARD Result
7546       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
7547                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7548                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7549                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7550 #else
7551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7552     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7553       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
7554                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7555                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7556                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7557 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7558 
7559 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7561     VULKAN_HPP_NODISCARD Result
7562       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
7563                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7564                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7565                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7566 #else
7567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7568     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7569       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
7570                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7571                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7572                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7573 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7574 
7575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7576     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
7577                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7578                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7579       VULKAN_HPP_NOEXCEPT;
7580 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7581     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7582     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements(
7583       VULKAN_HPP_NAMESPACE::Buffer buffer,
7584       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7585 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7586 
7587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7588     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
7589                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7590                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7591       VULKAN_HPP_NOEXCEPT;
7592 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7594     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements(
7595       VULKAN_HPP_NAMESPACE::Image image,
7596       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7597 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7598 
7599     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7600     void getImageSparseMemoryRequirements(
7601       VULKAN_HPP_NAMESPACE::Image                           image,
7602       uint32_t *                                            pSparseMemoryRequirementCount,
7603       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
7604       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7606     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
7607               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7608     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7609                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
7610                                                            Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7611     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
7612               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7613               typename B                                      = SparseImageMemoryRequirementsAllocator,
7614               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
7615                                       int>::type              = 0>
7616     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7617                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
7618                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
7619                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7620 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7621 
7622     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7623     VULKAN_HPP_NODISCARD Result
7624       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
7625                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7626                    VULKAN_HPP_NAMESPACE::Fence *                     pFence,
7627                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7628 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7630     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
7631       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo,
7632                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7633                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7634                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7635 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7636     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7637     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7638       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
7639       createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo,
7640                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7641                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7642                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7643 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7644 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7645 
7646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7647     void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
7648                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7649                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7651     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7652     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7653                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7654                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7655                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7656 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7657 
7658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7659     void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
7660                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7661                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7662 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7664     void destroy( VULKAN_HPP_NAMESPACE::Fence fence,
7665                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7666                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7667                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7668 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7669 
7670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7671     VULKAN_HPP_NODISCARD Result
7672       resetFences( uint32_t                            fenceCount,
7673                    const VULKAN_HPP_NAMESPACE::Fence * pFences,
7674                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7675 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7677     typename ResultValueType<void>::type
7678       resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
7679                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7680 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7681 
7682 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7684     VULKAN_HPP_NODISCARD Result
7685       getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
7686                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7687 #else
7688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7689     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
7690                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7691 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7692 
7693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7694     VULKAN_HPP_NODISCARD Result
7695       waitForFences( uint32_t                            fenceCount,
7696                      const VULKAN_HPP_NAMESPACE::Fence * pFences,
7697                      VULKAN_HPP_NAMESPACE::Bool32        waitAll,
7698                      uint64_t                            timeout,
7699                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7700 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7702     VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
7703                                                VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
7704                                                uint64_t                                              timeout,
7705                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7706 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7707 
7708     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7709     VULKAN_HPP_NODISCARD Result
7710       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
7711                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7712                        VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
7713                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7715     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7716     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
7717       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo,
7718                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7719                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7720                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7721 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7722     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7723     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7724       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
7725       createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo,
7726                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7727                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7728                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7729 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7730 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7731 
7732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7733     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
7734                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7735                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7736 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7737     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7738     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7739                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7740                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7741                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7742 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7743 
7744     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7745     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
7746                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7747                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7750     void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
7751                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7752                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7753                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7754 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7755 
7756     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7757     VULKAN_HPP_NODISCARD Result
7758       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
7759                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7760                    VULKAN_HPP_NAMESPACE::Event *                     pEvent,
7761                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7764     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
7765       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo,
7766                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7767                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7768                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7769 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7770     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7771     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7772       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
7773       createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo,
7774                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7775                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7776                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7777 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7778 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7779 
7780     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7781     void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
7782                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7783                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7784 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7785     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7786     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7787                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7788                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7789                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7790 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7791 
7792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7793     void destroy( VULKAN_HPP_NAMESPACE::Event                       event,
7794                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7795                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7798     void destroy( VULKAN_HPP_NAMESPACE::Event event,
7799                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7800                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7801                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7802 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7803 
7804 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7806     VULKAN_HPP_NODISCARD Result
7807       getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
7808                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7809 #else
7810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7811     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
7812                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7813 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7814 
7815 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7816     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7817     VULKAN_HPP_NODISCARD Result
7818       setEvent( VULKAN_HPP_NAMESPACE::Event event,
7819                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7820 #else
7821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7822     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7823       setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7824 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7825 
7826 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7828     VULKAN_HPP_NODISCARD Result
7829       resetEvent( VULKAN_HPP_NAMESPACE::Event event,
7830                   Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7831 #else
7832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7833     typename ResultValueType<void>::type
7834       resetEvent( VULKAN_HPP_NAMESPACE::Event event,
7835                   Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7836 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7837 
7838     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7839     VULKAN_HPP_NODISCARD Result
7840       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
7841                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7842                        VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
7843                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7844 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7846     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
7847       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo,
7848                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7849                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7850                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7851 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7852     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7853     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7854       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
7855       createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo,
7856                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7857                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7858                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7859 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7860 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7861 
7862     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7863     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
7864                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7865                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7866 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7868     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7869                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7870                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7871                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7872 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7873 
7874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7875     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
7876                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7877                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7880     void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
7881                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7882                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7883                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7884 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7885 
7886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7887     VULKAN_HPP_NODISCARD Result
7888       getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7889                            uint32_t                               firstQuery,
7890                            uint32_t                               queryCount,
7891                            size_t                                 dataSize,
7892                            void *                                 pData,
7893                            VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7894                            VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
7895                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7897     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7898     VULKAN_HPP_NODISCARD Result
7899       getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7900                            uint32_t                               firstQuery,
7901                            uint32_t                               queryCount,
7902                            ArrayProxy<T> const &                  data,
7903                            VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7904                            VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
7905                            Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7906     template <typename T,
7907               typename Allocator = std::allocator<T>,
7908               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7909     VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>>
7910                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
7911                                               uint32_t                                     firstQuery,
7912                                               uint32_t                                     queryCount,
7913                                               size_t                                       dataSize,
7914                                               VULKAN_HPP_NAMESPACE::DeviceSize             stride,
7915                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7916                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7917     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7918     VULKAN_HPP_NODISCARD ResultValue<T>
7919                          getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
7920                                              uint32_t                                     firstQuery,
7921                                              uint32_t                                     queryCount,
7922                                              VULKAN_HPP_NAMESPACE::DeviceSize             stride,
7923                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7924                                              Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7925 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7926 
7927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7928     VULKAN_HPP_NODISCARD Result
7929       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
7930                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7931                     VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,
7932                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7933 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7935     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
7936       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo,
7937                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7938                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7939                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7940 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7942     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7943       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
7944       createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo,
7945                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7946                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7947                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7948 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7949 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7950 
7951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7952     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
7953                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7954                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7955 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7957     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7958                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7959                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7960                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7961 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7962 
7963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7964     void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
7965                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7966                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7967 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7969     void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer,
7970                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7971                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7972                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7973 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7974 
7975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7976     VULKAN_HPP_NODISCARD Result
7977       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
7978                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
7979                         VULKAN_HPP_NAMESPACE::BufferView *                 pView,
7980                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7981 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7983     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
7984       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo,
7985                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7986                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7987                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7988 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7990     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7991       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
7992       createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo,
7993                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7994                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7995                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7996 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7997 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7998 
7999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8000     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
8001                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8002                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8003 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8005     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8006                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8007                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8008                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8009 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8010 
8011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8012     void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
8013                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8014                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8017     void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
8018                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8019                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8020                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8021 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8022 
8023     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8024     VULKAN_HPP_NODISCARD Result
8025       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
8026                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8027                    VULKAN_HPP_NAMESPACE::Image *                     pImage,
8028                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8029 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8031     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
8032       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo,
8033                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8034                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8035                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8036 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8038     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8039       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
8040       createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo,
8041                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8042                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8043                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8044 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8045 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8046 
8047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8048     void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
8049                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8050                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8052     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8053     void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8054                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8055                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8056                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8057 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8058 
8059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8060     void destroy( VULKAN_HPP_NAMESPACE::Image                       image,
8061                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8062                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8065     void destroy( VULKAN_HPP_NAMESPACE::Image image,
8066                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8067                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8068                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8069 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8070 
8071     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8072     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
8073                                     const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
8074                                     VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
8075                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8076       VULKAN_HPP_NOEXCEPT;
8077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8079     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout(
8080       VULKAN_HPP_NAMESPACE::Image                    image,
8081       const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
8082       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8083 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8084 
8085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8086     VULKAN_HPP_NODISCARD Result
8087       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
8088                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8089                        VULKAN_HPP_NAMESPACE::ImageView *                 pView,
8090                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8092     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8093     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
8094       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo,
8095                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8096                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8097                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8098 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8100     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8101       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
8102       createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo,
8103                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8104                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8105                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8106 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8107 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8108 
8109     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8110     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
8111                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8112                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8113 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8114     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8115     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8116                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8117                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8118                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8119 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8120 
8121     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8122     void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
8123                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8124                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8126     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8127     void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
8128                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8129                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8130                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8131 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8132 
8133     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8134     VULKAN_HPP_NODISCARD Result
8135       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
8136                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
8137                           VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
8138                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8141     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
8142       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
8143                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8144                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8145                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8146 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8148     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8149       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
8150       createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
8151                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8152                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8153                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8154 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8155 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8156 
8157     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8158     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
8159                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8160                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8161 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8163     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8164                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8165                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8166                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8167 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8168 
8169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8170     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
8171                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8172                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8173 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8174     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8175     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
8176                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8177                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8178                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8179 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8180 
8181     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8182     VULKAN_HPP_NODISCARD Result
8183       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
8184                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
8185                            VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
8186                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8187 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8189     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
8190       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo,
8191                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8192                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8193                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8194 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8196     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8197       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
8198       createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo,
8199                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8200                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8201                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8202 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8203 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8204 
8205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8206     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
8207                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8208                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8209 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8210     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8211     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8212                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8213                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8214                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8215 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8216 
8217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8218     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
8219                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8220                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8222     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8223     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8224                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8225                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8226                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8227 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8228 
8229     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8230     VULKAN_HPP_NODISCARD Result
8231       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8232                             size_t *                            pDataSize,
8233                             void *                              pData,
8234                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8236     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
8237               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8238     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
8239       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8240                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8241     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
8242               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8243               typename B                = Uint8_tAllocator,
8244               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
8245     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
8246       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8247                             Uint8_tAllocator &                  uint8_tAllocator,
8248                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8249 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8250 
8251     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8252     VULKAN_HPP_NODISCARD Result
8253       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
8254                            uint32_t                                    srcCacheCount,
8255                            const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
8256                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8259     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8260       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
8261                            ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
8262                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8264 
8265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8266     VULKAN_HPP_NODISCARD Result
8267       createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
8268                                uint32_t                                                 createInfoCount,
8269                                const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
8270                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
8271                                VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
8272                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8273 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8274     template <typename PipelineAllocator = std::allocator<Pipeline>,
8275               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8276     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8277                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8278                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8279                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8280                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8281                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8282     template <typename PipelineAllocator = std::allocator<Pipeline>,
8283               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8284               typename B                 = PipelineAllocator,
8285               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
8286     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8287                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8288                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8289                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                  allocator,
8290                                                   PipelineAllocator & pipelineAllocator,
8291                                                   Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8293     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
8294                          createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
8295                                                  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
8296                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8297                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8298                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8299 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8300     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8301               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
8302     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8303                          createGraphicsPipelinesUnique(
8304                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8305                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8306                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8307                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8308                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8309     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8310               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
8311               typename B                         = PipelineAllocator,
8312               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
8313                                       int>::type = 0>
8314     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8315                          createGraphicsPipelinesUnique(
8316                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8317                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8318                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                  allocator,
8319                            PipelineAllocator &                                                        pipelineAllocator,
8320                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8322     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
8323                          createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
8324                                                        const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
8325                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8326                                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8327                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8328 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8329 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8330 
8331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8332     VULKAN_HPP_NODISCARD Result
8333       createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
8334                               uint32_t                                                createInfoCount,
8335                               const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
8336                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
8337                               VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,
8338                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8339 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8340     template <typename PipelineAllocator = std::allocator<Pipeline>,
8341               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8342     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8343                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8344                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8345                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8346                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8347                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8348     template <typename PipelineAllocator = std::allocator<Pipeline>,
8349               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8350               typename B                 = PipelineAllocator,
8351               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
8352     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8353                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8354                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8355                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                 allocator,
8356                                                  PipelineAllocator & pipelineAllocator,
8357                                                  Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8358     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8359     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
8360                          createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
8361                                                 const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
8362                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8363                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8364                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8365 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8366     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8367               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
8368     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8369                          createComputePipelinesUnique(
8370                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8371                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8372                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8373                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8374                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8375     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8376               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
8377               typename B                         = PipelineAllocator,
8378               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
8379                                       int>::type = 0>
8380     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8381                          createComputePipelinesUnique(
8382                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8383                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8384                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                 allocator,
8385                            PipelineAllocator &                                                       pipelineAllocator,
8386                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8388     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
8389                          createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
8390                                                       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
8391                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8392                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8393                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8394 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8395 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8396 
8397     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8398     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
8399                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8400                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8401 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8402     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8403     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8404                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8405                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8406                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8407 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8408 
8409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8410     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
8411                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8412                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8415     void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
8416                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8417                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8418                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8419 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8420 
8421     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8422     VULKAN_HPP_NODISCARD Result
8423       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
8424                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
8425                             VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
8426                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8428     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8429     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
8430       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo,
8431                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8432                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8433                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8434 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8436     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8437       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
8438       createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo,
8439                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8440                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8441                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8442 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8443 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8444 
8445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8446     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
8447                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8448                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8450     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8451     void
8452       destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8453                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8454                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8455                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8456 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8457 
8458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8459     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
8460                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8461                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8464     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
8465                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8466                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8467                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8468 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8469 
8470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8471     VULKAN_HPP_NODISCARD Result
8472       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
8473                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8474                      VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
8475                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8476 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8477     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8478     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
8479       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo,
8480                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8481                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8482                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8483 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8484     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8485     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8486       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
8487       createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo,
8488                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8489                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8490                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8491 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8492 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8493 
8494     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8495     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
8496                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8497                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8499     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8500     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8501                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8502                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8503                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8504 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8505 
8506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8507     void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
8508                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8509                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8512     void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler,
8513                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8514                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8515                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8516 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8517 
8518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8519     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(
8520       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
8521       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
8522       VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
8523       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8526     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
8527       createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
8528                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8529                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8530                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8531 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8533     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8534       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
8535       createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
8536                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8537                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8538                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8539 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8540 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8541 
8542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8543     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
8544                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8545                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8546       VULKAN_HPP_NOEXCEPT;
8547 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8549     void destroyDescriptorSetLayout(
8550       VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8551       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8552                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8553       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8554 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8555 
8556     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8557     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
8558                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8559                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8560 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8562     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
8563                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8564                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8565                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8566 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8567 
8568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8569     VULKAN_HPP_NODISCARD Result
8570       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
8571                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
8572                             VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,
8573                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8576     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
8577       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo,
8578                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8579                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8580                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8581 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8583     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8584       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
8585       createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo,
8586                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8587                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8588                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8589 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8590 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8591 
8592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8593     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
8594                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8595                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8596 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8598     void
8599       destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8600                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8601                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8602                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8603 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8604 
8605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8606     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
8607                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8608                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8609 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8611     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
8612                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8613                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8614                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8615 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8616 
8617 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8619     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
8620                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
8621                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8622 #else
8623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8624     typename ResultValueType<void>::type
8625       resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
8626                            VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8627                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8628 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8629 
8630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8631     VULKAN_HPP_NODISCARD Result
8632       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
8633                               VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
8634                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8635 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8636     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
8637               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8638     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8639       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
8640       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8641                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8642     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
8643               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8644               typename B                      = DescriptorSetAllocator,
8645               typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
8646     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8647       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
8648       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8649                               DescriptorSetAllocator &                                descriptorSetAllocator,
8650                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8651 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8652     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8653               typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
8654     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8655       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
8656       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8657                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8658     template <
8659       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8660       typename DescriptorSetAllocator    = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
8661       typename B                         = DescriptorSetAllocator,
8662       typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
8663                               int>::type = 0>
8664     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8665       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
8666       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8667                                     DescriptorSetAllocator &                                descriptorSetAllocator,
8668                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8669 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8670 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8671 
8672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8673     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
8674                                uint32_t                                    descriptorSetCount,
8675                                const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8676                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8677 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8678     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8679     typename ResultValueType<void>::type
8680       freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
8681                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
8682                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8683 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8684 
8685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8686     Result free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
8687                  uint32_t                                    descriptorSetCount,
8688                  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8689                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8691     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8692     typename ResultValueType<void>::type
8693       free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
8694             ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
8695             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8696 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8697 
8698     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8699     void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
8700                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
8701                                uint32_t                                         descriptorCopyCount,
8702                                const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
8703                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8704 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8706     void updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
8707                                ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
8708                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8709 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8710 
8711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8712     VULKAN_HPP_NODISCARD Result
8713       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
8714                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8715                          VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
8716                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8719     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
8720       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo,
8721                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8722                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8723                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8724 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8726     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8727       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
8728       createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo,
8729                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8730                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8731                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8732 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8733 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8734 
8735     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8736     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
8737                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8738                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8740     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8741     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8742                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8743                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8744                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8745 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8746 
8747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8748     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
8749                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8750                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8753     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
8754                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8755                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8756                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8757 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8758 
8759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8760     VULKAN_HPP_NODISCARD Result
8761       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
8762                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
8763                         VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
8764                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8767     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
8768       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo,
8769                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8770                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8771                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8772 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8774     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8775       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
8776       createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo,
8777                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8778                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8779                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8780 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8781 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8782 
8783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8784     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
8785                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8786                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8789     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8790                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8791                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8792                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8793 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8794 
8795     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8796     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
8797                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8798                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8801     void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8802                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8803                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8804                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8805 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8806 
8807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8808     void
8809       getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8810                                 VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
8811                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8814     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
8815                          getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8816                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8817 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8818 
8819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8820     VULKAN_HPP_NODISCARD Result
8821       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
8822                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8823                          VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
8824                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8825 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8826     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8827     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
8828       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo,
8829                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8830                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8831                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8832 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8833     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8834     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8835       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
8836       createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo,
8837                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8838                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8839                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8840 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8841 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8842 
8843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8844     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8845                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8846                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8849     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8850                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8851                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8852                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8853 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8854 
8855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8856     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8857                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8858                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8859 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8860     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8861     void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
8862                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8863                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8864                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8865 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8866 
8867 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8869     VULKAN_HPP_NODISCARD Result
8870       resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8871                         VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
8872                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8873 #else
8874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8875     typename ResultValueType<void>::type
8876       resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8877                         VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8878                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8879 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8880 
8881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8882     VULKAN_HPP_NODISCARD Result
8883       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
8884                               VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
8885                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8887     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
8888               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8889     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8890       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
8891       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8892                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8893     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
8894               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8895               typename B                      = CommandBufferAllocator,
8896               typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
8897     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8898       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
8899       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8900                               CommandBufferAllocator &                                commandBufferAllocator,
8901                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8902 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8903     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8904               typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
8905     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8906       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
8907       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8908                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8909     template <
8910       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8911       typename CommandBufferAllocator    = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
8912       typename B                         = CommandBufferAllocator,
8913       typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
8914                               int>::type = 0>
8915     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8916       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
8917       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8918                                     CommandBufferAllocator &                                commandBufferAllocator,
8919                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8920 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8921 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8922 
8923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8924     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8925                              uint32_t                                    commandBufferCount,
8926                              const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
8927                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8928 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8929     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8930     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
8931                              ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
8932                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8933 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8934 
8935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8936     void free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8937                uint32_t                                    commandBufferCount,
8938                const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
8939                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8940 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8942     void free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
8943                ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
8944                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8945 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8946 
8947     //=== VK_VERSION_1_1 ===
8948 
8949     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8950     VULKAN_HPP_NODISCARD Result
8951       bindBufferMemory2( uint32_t                                           bindInfoCount,
8952                          const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
8953                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8956     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8957       bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
8958                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8959 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8960 
8961     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8962     VULKAN_HPP_NODISCARD Result
8963       bindImageMemory2( uint32_t                                          bindInfoCount,
8964                         const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
8965                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8966 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8967     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8968     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8969       bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
8970                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8971 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8972 
8973     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8974     void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
8975                                      uint32_t                                       localDeviceIndex,
8976                                      uint32_t                                       remoteDeviceIndex,
8977                                      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
8978                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8979       VULKAN_HPP_NOEXCEPT;
8980 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8982     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
8983       uint32_t           heapIndex,
8984       uint32_t           localDeviceIndex,
8985       uint32_t           remoteDeviceIndex,
8986       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8987 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8988 
8989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8990     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
8991                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
8992                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8993       VULKAN_HPP_NOEXCEPT;
8994 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8995     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8996     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(
8997       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
8998       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8999     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9000     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2(
9001       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
9002       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9003 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9004 
9005     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9006     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
9007                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
9008                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9009       VULKAN_HPP_NOEXCEPT;
9010 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9012     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(
9013       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
9014       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9015     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9016     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2(
9017       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
9018       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9019 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9020 
9021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9022     void getImageSparseMemoryRequirements2(
9023       const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
9024       uint32_t *                                                       pSparseMemoryRequirementCount,
9025       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
9026       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9028     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
9029               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9030     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9031       getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
9032                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9033     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
9034               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9035               typename B                                       = SparseImageMemoryRequirements2Allocator,
9036               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
9037                                       int>::type               = 0>
9038     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9039                          getImageSparseMemoryRequirements2(
9040                            const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
9041                            SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
9042                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9043 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9044 
9045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9046     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
9047                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
9048                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9049 
9050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9051     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
9052                     VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
9053                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9056     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
9057                          getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,
9058                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9059 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9060 
9061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9062     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(
9063       const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
9064       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
9065       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
9066       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9069     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
9070       createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
9071                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9072                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9073                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9074 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9075     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9076     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9077       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
9078       createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
9079                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9080                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9081                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9082 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9083 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9084 
9085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9086     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
9087                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9088                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9089       VULKAN_HPP_NOEXCEPT;
9090 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9091     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9092     void destroySamplerYcbcrConversion(
9093       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9094       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9095                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9096       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9097 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9098 
9099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9100     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
9101                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9102                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9105     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
9106                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9107                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9108                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9109 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9110 
9111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9112     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(
9113       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
9114       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
9115       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
9116       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9117 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9118     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9119     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9120       typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
9121       createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
9122                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9123                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9124                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9125 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9126     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9127     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9128       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
9129       createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
9130                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9131                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9132                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9133 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9134 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9135 
9136     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9137     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
9138                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9139                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9140       VULKAN_HPP_NOEXCEPT;
9141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9143     void destroyDescriptorUpdateTemplate(
9144       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9145       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9146                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9147       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9148 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9149 
9150     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9151     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
9152                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9153                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9156     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9157                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9158                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9159                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9160 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9161 
9162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9163     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
9164                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9165                                           const void *                                   pData,
9166                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9167       VULKAN_HPP_NOEXCEPT;
9168 
9169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9170     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
9171                                         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
9172                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9173       VULKAN_HPP_NOEXCEPT;
9174 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9176     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
9177       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
9178       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9179     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9180     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(
9181       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
9182       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9183 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9184 
9185     //=== VK_VERSION_1_2 ===
9186 
9187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9188     VULKAN_HPP_NODISCARD Result
9189       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
9190                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9191                          VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
9192                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9195     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
9196       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
9197                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9198                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9199                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9200 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9201     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9202     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9203       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
9204       createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
9205                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9206                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9207                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9208 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9209 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9210 
9211     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9212     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9213                          uint32_t                        firstQuery,
9214                          uint32_t                        queryCount,
9215                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9216 
9217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9218     VULKAN_HPP_NODISCARD Result
9219       getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9220                                 uint64_t *                      pValue,
9221                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9222 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9223     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9224     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
9225       getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9226                                 Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9227 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9228 
9229     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9230     VULKAN_HPP_NODISCARD Result
9231       waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
9232                       uint64_t                                        timeout,
9233                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9236     VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
9237                                                 uint64_t                                        timeout,
9238                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9239 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9240 
9241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9242     VULKAN_HPP_NODISCARD Result
9243       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
9244                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9245 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9247     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9248       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo,
9249                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9250 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9251 
9252     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9253     DeviceAddress
9254       getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
9255                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9256 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9258     DeviceAddress
9259       getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
9260                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9261 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9262 
9263     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9264     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
9265                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9266       VULKAN_HPP_NOEXCEPT;
9267 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9269     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
9270                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9271       VULKAN_HPP_NOEXCEPT;
9272 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9273 
9274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9275     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
9276                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9277       VULKAN_HPP_NOEXCEPT;
9278 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9279     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9280     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
9281                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9282       VULKAN_HPP_NOEXCEPT;
9283 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9284 
9285     //=== VK_KHR_swapchain ===
9286 
9287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9288     VULKAN_HPP_NODISCARD Result
9289       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
9290                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
9291                           VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
9292                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9293 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9294     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9295     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
9296       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9297                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9298                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9299                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9300 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9301     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9302     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9303       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
9304       createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9305                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9306                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9307                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9308 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9309 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9310 
9311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9312     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
9313                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9314                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9315 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9317     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9318                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9319                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9320                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9321 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9322 
9323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9324     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
9325                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9326                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9329     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9330                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9331                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9332                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9333 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9334 
9335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9336     VULKAN_HPP_NODISCARD Result
9337       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9338                              uint32_t *                         pSwapchainImageCount,
9339                              VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
9340                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9342     template <typename ImageAllocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9343     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
9344       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9345                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9346     template <typename ImageAllocator = std::allocator<Image>,
9347               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9348               typename B              = ImageAllocator,
9349               typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
9350     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
9351       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9352                              ImageAllocator &                   imageAllocator,
9353                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9354 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9355 
9356     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9357     VULKAN_HPP_NODISCARD Result
9358       acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9359                            uint64_t                           timeout,
9360                            VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
9361                            VULKAN_HPP_NAMESPACE::Fence        fence,
9362                            uint32_t *                         pImageIndex,
9363                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9365     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9366     VULKAN_HPP_NODISCARD ResultValue<uint32_t>
9367                          acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
9368                                               uint64_t                                  timeout,
9369                                               VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9370                                               VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9371                                               Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9372 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9373 
9374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9375     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(
9376       VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
9377       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9378 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9380     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9381       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
9382       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9383 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9384 
9385     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9386     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(
9387       VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
9388       VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
9389       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9390 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9392     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9393       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
9394       getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
9395                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9396 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9397 
9398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9399     VULKAN_HPP_NODISCARD Result
9400       acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
9401                             uint32_t *                                            pImageIndex,
9402                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9405     VULKAN_HPP_NODISCARD ResultValue<uint32_t>
9406                          acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,
9407                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9408 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9409 
9410     //=== VK_KHR_display_swapchain ===
9411 
9412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9413     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(
9414       uint32_t                                             swapchainCount,
9415       const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
9416       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
9417       VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
9418       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9419 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9420     template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
9421               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9422     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9423       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
9424       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9425                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9426                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9427                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9428     template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
9429               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9430               typename B                     = SwapchainKHRAllocator,
9431               typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
9432     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9433       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
9434       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9435                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>              allocator,
9436                                  SwapchainKHRAllocator & swapchainKHRAllocator,
9437                                  Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9439     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
9440       createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9441                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9442                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9443                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9444 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9445     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9446               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
9447     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9448       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
9449       createSharedSwapchainsKHRUnique(
9450         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9451         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9452                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9453         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9454     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9455               typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
9456               typename B                         = SwapchainKHRAllocator,
9457               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
9458                                       int>::type = 0>
9459     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9460       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
9461       createSharedSwapchainsKHRUnique(
9462         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9463         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>              allocator,
9464         SwapchainKHRAllocator &                                                swapchainKHRAllocator,
9465         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9467     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
9468       createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9469                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9470                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9471                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9472 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9473 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9474 
9475     //=== VK_EXT_debug_marker ===
9476 
9477     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9478     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(
9479       const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
9480       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9483     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9484       debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,
9485                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9486 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9487 
9488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9489     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(
9490       const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
9491       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9492 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9494     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9495       debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,
9496                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9497 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9498 
9499 #if defined( VK_ENABLE_BETA_EXTENSIONS )
9500     //=== VK_KHR_video_queue ===
9501 
9502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9503     VULKAN_HPP_NODISCARD Result
9504       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
9505                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
9506                              VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
9507                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9508 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9510     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
9511       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
9512                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9513                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9514                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9515 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
9516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9517     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9518       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
9519       createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
9520                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9521                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9522                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9523 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9524 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9525 
9526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9527     void
9528       destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
9529                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9530                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9531 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9533     void
9534       destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9535                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9536                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9537                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9538 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9539 
9540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9541     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
9542                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9543                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9544 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9546     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9547                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9548                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9549                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9550 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9551 
9552     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9553     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(
9554       VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
9555       uint32_t *                                          pVideoSessionMemoryRequirementsCount,
9556       VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
9557       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9558 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9559     template <typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
9560               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9561     VULKAN_HPP_NODISCARD
9562       typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
9563       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9564                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9565     template <
9566       typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
9567       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9568       typename B                                    = VideoGetMemoryPropertiesKHRAllocator,
9569       typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type = 0>
9570     VULKAN_HPP_NODISCARD
9571       typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
9572       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
9573                                             VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
9574                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9575 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9576 
9577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9578     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(
9579       VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
9580       uint32_t                                         videoSessionBindMemoryCount,
9581       const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
9582       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9583 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9585     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR(
9586       VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
9587       ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
9588       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9589 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9590 
9591     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9592     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(
9593       const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
9594       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
9595       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
9596       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9597 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9599     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9600       typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
9601       createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
9602                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9603                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9604                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9605 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
9606     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9607     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9608       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
9609       createVideoSessionParametersKHRUnique(
9610         const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
9611         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9612                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9613         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9614 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9615 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9616 
9617     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9618     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(
9619       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
9620       const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
9621       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9622 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9624     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9625       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9626                                        const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
9627                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9628 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9629 
9630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9631     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
9632                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9633                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9634       VULKAN_HPP_NOEXCEPT;
9635 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9636     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9637     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9638                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9639                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9640                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9641       VULKAN_HPP_NOEXCEPT;
9642 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9643 
9644     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9645     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
9646                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9647                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9648 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9650     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9651                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9652                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9653                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9654 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9655 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
9656 
9657     //=== VK_NVX_binary_import ===
9658 
9659     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9660     VULKAN_HPP_NODISCARD Result
9661       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
9662                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9663                          VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
9664                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9667     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
9668       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo,
9669                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9670                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9671                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9672 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9673     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9674     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9675       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
9676       createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo,
9677                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9678                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9679                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9680 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9681 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9682 
9683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9684     VULKAN_HPP_NODISCARD Result
9685       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
9686                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
9687                            VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
9688                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9690     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9691     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
9692       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo,
9693                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9694                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9695                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9696 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9698     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9699       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
9700       createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo,
9701                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9702                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9703                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9704 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9705 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9706 
9707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9708     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
9709                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9710                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9711 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9713     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
9714                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9715                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9716                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9717 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9718 
9719     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9720     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
9721                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9722                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9725     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
9726                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9727                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9728                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9729 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9730 
9731     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9732     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
9733                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9734                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9735 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9737     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
9738                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9739                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9740                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9741 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9742 
9743     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9744     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
9745                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9746                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9749     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
9750                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9751                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9752                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9753 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9754 
9755     //=== VK_NVX_image_view_handle ===
9756 
9757     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9758     uint32_t
9759       getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
9760                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9761 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9763     uint32_t
9764       getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
9765                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9766 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9767 
9768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9769     VULKAN_HPP_NODISCARD Result
9770       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
9771                               VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
9772                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9773 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9774     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9775     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9776       typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
9777       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
9778                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9779 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9780 
9781     //=== VK_AMD_shader_info ===
9782 
9783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9784     VULKAN_HPP_NODISCARD Result
9785       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9786                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9787                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9788                         size_t *                                  pInfoSize,
9789                         void *                                    pInfo,
9790                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9791 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9792     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9793               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9794     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9795       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9796                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9797                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9798                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9799     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9800               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9801               typename B                = Uint8_tAllocator,
9802               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
9803     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9804       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9805                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9806                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9807                         Uint8_tAllocator &                        uint8_tAllocator,
9808                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9809 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9810 
9811 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9812     //=== VK_NV_external_memory_win32 ===
9813 
9814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9815     VULKAN_HPP_NODISCARD Result
9816       getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
9817                               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
9818                               HANDLE *                                              pHandle,
9819                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9820 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9822     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9823       getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
9824                               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
9825                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9826 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9827 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9828 
9829     //=== VK_KHR_device_group ===
9830 
9831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9832     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
9833                                         uint32_t                                       localDeviceIndex,
9834                                         uint32_t                                       remoteDeviceIndex,
9835                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
9836                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9837       VULKAN_HPP_NOEXCEPT;
9838 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9839     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9840     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
9841       uint32_t           heapIndex,
9842       uint32_t           localDeviceIndex,
9843       uint32_t           remoteDeviceIndex,
9844       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9845 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9846 
9847     //=== VK_KHR_maintenance1 ===
9848 
9849     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9850     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
9851                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
9852                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9853 
9854 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9855     //=== VK_KHR_external_memory_win32 ===
9856 
9857     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9858     VULKAN_HPP_NODISCARD Result
9859       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9860                                HANDLE *                                                  pHandle,
9861                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9862 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9864     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9865       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
9866                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9867 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9868 
9869     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9870     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR(
9871       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9872       HANDLE                                                 handle,
9873       VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
9874       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9875 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9876     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9877     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9878       typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
9879       getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9880                                          HANDLE                                                 handle,
9881                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9882 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9883 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9884 
9885     //=== VK_KHR_external_memory_fd ===
9886 
9887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9888     VULKAN_HPP_NODISCARD Result
9889       getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
9890                       int *                                            pFd,
9891                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9892 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9893     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9894     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
9895       getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,
9896                       Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9897 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9898 
9899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9900     VULKAN_HPP_NODISCARD Result
9901       getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9902                                 int                                                    fd,
9903                                 VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
9904                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9907     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
9908       getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9909                                 int                                                    fd,
9910                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9911 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9912 
9913 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9914     //=== VK_KHR_external_semaphore_win32 ===
9915 
9916     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9917     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR(
9918       const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
9919       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9920 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9922     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreWin32HandleKHR(
9923       const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
9924       Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9925 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9926 
9927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9928     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR(
9929       const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9930       HANDLE *                                                     pHandle,
9931       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9932 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9933     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9934     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9935       getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
9936                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9937 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9938 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9939 
9940     //=== VK_KHR_external_semaphore_fd ===
9941 
9942     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9943     VULKAN_HPP_NODISCARD Result
9944       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
9945                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9948     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9949       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
9950                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9951 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9952 
9953     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9954     VULKAN_HPP_NODISCARD Result
9955       getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
9956                          int *                                               pFd,
9957                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9960     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
9961       getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,
9962                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9963 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9964 
9965     //=== VK_KHR_descriptor_update_template ===
9966 
9967     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9968     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(
9969       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
9970       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
9971       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
9972       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9974     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9975     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9976       typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
9977       createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
9978                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9979                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9980                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9981 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9983     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9984       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
9985       createDescriptorUpdateTemplateKHRUnique(
9986         const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
9987         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9988                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9989         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9990 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9991 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9992 
9993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9994     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
9995                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9996                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9997       VULKAN_HPP_NOEXCEPT;
9998 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10000     void destroyDescriptorUpdateTemplateKHR(
10001       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10002       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10003                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10004       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10005 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10006 
10007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10008     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
10009                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10010                                              const void *                                   pData,
10011                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10012       VULKAN_HPP_NOEXCEPT;
10013 
10014     //=== VK_EXT_display_control ===
10015 
10016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10017     VULKAN_HPP_NODISCARD Result
10018       displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10019                               const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
10020                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10022     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10023     typename ResultValueType<void>::type
10024       displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10025                               const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
10026                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10027 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10028 
10029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10030     VULKAN_HPP_NODISCARD Result
10031       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
10032                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10033                         VULKAN_HPP_NAMESPACE::Fence *                     pFence,
10034                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10035 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10036     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10037     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
10038       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo,
10039                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10040                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10041                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10042 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10044     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
10045       registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo,
10046                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10047                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10048                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10049 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10050 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10051 
10052     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10053     VULKAN_HPP_NODISCARD Result
10054       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10055                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
10056                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10057                                VULKAN_HPP_NAMESPACE::Fence *                     pFence,
10058                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10061     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
10062       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10063                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
10064                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10065                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10066                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10067 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10069     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
10070       registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10071                                      const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
10072                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10073                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10074                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10075 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10076 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10077 
10078     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10079     VULKAN_HPP_NODISCARD Result
10080       getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
10081                               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
10082                               uint64_t *                                      pCounterValue,
10083                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10084 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10086     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
10087       getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
10088                               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
10089                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10090 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10091 
10092     //=== VK_GOOGLE_display_timing ===
10093 
10094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10095     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(
10096       VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
10097       VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
10098       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10101     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10102       typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
10103       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10104                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10105 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10106 
10107     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10108     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(
10109       VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
10110       uint32_t *                                           pPresentationTimingCount,
10111       VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
10112       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10113 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10114     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
10115               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10116     VULKAN_HPP_NODISCARD
10117       typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
10118       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10119                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10120     template <
10121       typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
10122       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10123       typename B                                     = PastPresentationTimingGOOGLEAllocator,
10124       typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
10125     VULKAN_HPP_NODISCARD
10126       typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
10127       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
10128                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
10129                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10130 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10131 
10132     //=== VK_EXT_hdr_metadata ===
10133 
10134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10135     void setHdrMetadataEXT( uint32_t                                     swapchainCount,
10136                             const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
10137                             const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
10138                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10141     void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
10142                             ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
10143                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10144       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
10145 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10146 
10147     //=== VK_KHR_create_renderpass2 ===
10148 
10149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10150     VULKAN_HPP_NODISCARD Result
10151       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
10152                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10153                             VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
10154                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10157     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
10158       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
10159                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10160                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10161                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10162 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10163     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10164     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10165       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
10166       createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
10167                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10168                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10169                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10170 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10171 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10172 
10173     //=== VK_KHR_shared_presentable_image ===
10174 
10175 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10176     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10177     VULKAN_HPP_NODISCARD Result
10178       getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10179                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10180 #else
10181     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10182     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(
10183       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10184 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10185 
10186 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10187     //=== VK_KHR_external_fence_win32 ===
10188 
10189     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10190     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR(
10191       const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
10192       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10193 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10195     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10196       importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
10197                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10198 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10199 
10200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10201     VULKAN_HPP_NODISCARD Result
10202       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
10203                               HANDLE *                                                 pHandle,
10204                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10205 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10207     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
10208       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
10209                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10210 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10211 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
10212 
10213     //=== VK_KHR_external_fence_fd ===
10214 
10215     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10216     VULKAN_HPP_NODISCARD Result
10217       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
10218                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10219 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10221     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10222       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,
10223                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10224 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10225 
10226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10227     VULKAN_HPP_NODISCARD Result
10228       getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
10229                      int *                                           pFd,
10230                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10233     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
10234       getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,
10235                      Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10236 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10237 
10238     //=== VK_KHR_performance_query ===
10239 
10240     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10241     VULKAN_HPP_NODISCARD Result
10242       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
10243                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10244 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10245     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10246     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10247       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,
10248                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10249 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10250 
10251     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10252     void
10253       releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10254 
10255     //=== VK_EXT_debug_utils ===
10256 
10257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10258     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
10259       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
10260       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10261 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10263     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10264       setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,
10265                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10266 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10267 
10268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10269     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(
10270       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
10271       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10273     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10274     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10275       setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,
10276                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10277 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10278 
10279 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
10280     //=== VK_ANDROID_external_memory_android_hardware_buffer ===
10281 
10282     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10283     VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID(
10284       const struct AHardwareBuffer *                                 buffer,
10285       VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
10286       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10287 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10288     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10289     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10290       typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
10291       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
10292                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10293     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10294     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
10295       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
10296                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10297 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10298 
10299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10300     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID(
10301       const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
10302       struct AHardwareBuffer **                                               pBuffer,
10303       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10304 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10306     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<struct AHardwareBuffer *>::type
10307       getMemoryAndroidHardwareBufferANDROID(
10308         const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
10309         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10310 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10311 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
10312 
10313     //=== VK_KHR_get_memory_requirements2 ===
10314 
10315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10316     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
10317                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
10318                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10319       VULKAN_HPP_NOEXCEPT;
10320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10322     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(
10323       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10324       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10325     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10326     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(
10327       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10328       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10329 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10330 
10331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10332     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
10333                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10334                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10335       VULKAN_HPP_NOEXCEPT;
10336 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10338     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(
10339       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10340       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10341     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10342     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(
10343       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10344       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10345 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10346 
10347     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10348     void getImageSparseMemoryRequirements2KHR(
10349       const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
10350       uint32_t *                                                       pSparseMemoryRequirementCount,
10351       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
10352       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10353 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10354     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
10355               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10356     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10357       getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10358                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10359     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
10360               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10361               typename B                                       = SparseImageMemoryRequirements2Allocator,
10362               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
10363                                       int>::type               = 0>
10364     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10365                          getImageSparseMemoryRequirements2KHR(
10366                            const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10367                            SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
10368                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10369 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10370 
10371     //=== VK_KHR_acceleration_structure ===
10372 
10373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10374     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(
10375       const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
10376       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
10377       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
10378       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10379 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10380     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10381     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10382       typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
10383       createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo,
10384                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10385                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10386                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10387 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10389     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10390       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
10391       createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo,
10392                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10393                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10394                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10395 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10396 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10397 
10398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10399     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
10400                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10401                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10402       VULKAN_HPP_NOEXCEPT;
10403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10405     void destroyAccelerationStructureKHR(
10406       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10407       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10408                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10409       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10410 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10411 
10412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10413     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
10414                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
10419                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10420                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10421                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10422 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10423 
10424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10425     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(
10426       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
10427       uint32_t                                                                     infoCount,
10428       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
10429       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
10430       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10431 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10433     Result buildAccelerationStructuresKHR(
10434       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
10435       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
10436       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
10437       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
10438 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10439 
10440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10441     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(
10442       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
10443       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
10444       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10445 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10446     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10447     VULKAN_HPP_NODISCARD Result
10448       copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
10449                                     const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
10450                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10451 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10452 
10453     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10454     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(
10455       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
10456       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
10457       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10458 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10459     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10460     VULKAN_HPP_NODISCARD Result
10461       copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
10462                                             const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
10463                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10464 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10465 
10466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10467     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(
10468       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
10469       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
10470       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10473     VULKAN_HPP_NODISCARD Result
10474       copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
10475                                             const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
10476                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10477 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10478 
10479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10480     VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(
10481       uint32_t                                               accelerationStructureCount,
10482       const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
10483       VULKAN_HPP_NAMESPACE::QueryType                        queryType,
10484       size_t                                                 dataSize,
10485       void *                                                 pData,
10486       size_t                                                 stride,
10487       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10489     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10490     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10491       writeAccelerationStructuresPropertiesKHR(
10492         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
10493         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
10494         ArrayProxy<T> const &                                                    data,
10495         size_t                                                                   stride,
10496         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10497     template <typename T,
10498               typename Allocator = std::allocator<T>,
10499               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10500     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10501       writeAccelerationStructuresPropertiesKHR(
10502         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
10503         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
10504         size_t                                                                   dataSize,
10505         size_t                                                                   stride,
10506         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10507     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10508     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR(
10509       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
10510       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
10511       size_t                                                                   stride,
10512       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10513 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10514 
10515     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10516     DeviceAddress getAccelerationStructureAddressKHR(
10517       const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
10518       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10519 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10521     DeviceAddress getAccelerationStructureAddressKHR(
10522       const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,
10523       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10524 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10525 
10526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10527     void getAccelerationStructureCompatibilityKHR(
10528       const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
10529       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
10530       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10531 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10532     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10533     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
10534                          getAccelerationStructureCompatibilityKHR(
10535                            const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,
10536                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10537 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10538 
10539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10540     void getAccelerationStructureBuildSizesKHR(
10541       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
10542       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
10543       const uint32_t *                                                        pMaxPrimitiveCounts,
10544       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
10545       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10546 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10548     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
10549                          getAccelerationStructureBuildSizesKHR(
10550                            VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
10551                            const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,
10552                            ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10553                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
10554 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10555 
10556     //=== VK_KHR_sampler_ycbcr_conversion ===
10557 
10558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10559     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(
10560       const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
10561       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
10562       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
10563       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10566     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
10567       createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
10568                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10569                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10570                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10571 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10572     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10573     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10574       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
10575       createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
10576                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10577                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10578                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10579 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10580 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10581 
10582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10583     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
10584                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10585                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10586       VULKAN_HPP_NOEXCEPT;
10587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10589     void destroySamplerYcbcrConversionKHR(
10590       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10591       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10592                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10593       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10594 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10595 
10596     //=== VK_KHR_bind_memory2 ===
10597 
10598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10599     VULKAN_HPP_NODISCARD Result
10600       bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
10601                             const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
10602                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10603 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10604     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10605     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10606       bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
10607                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10608 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10609 
10610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10611     VULKAN_HPP_NODISCARD Result
10612       bindImageMemory2KHR( uint32_t                                          bindInfoCount,
10613                            const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
10614                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10615 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10617     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10618       bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
10619                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10620 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10621 
10622     //=== VK_EXT_image_drm_format_modifier ===
10623 
10624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10625     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(
10626       VULKAN_HPP_NAMESPACE::Image                                 image,
10627       VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
10628       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10629 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10631     typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
10632       getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image,
10633                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10634 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10635 
10636     //=== VK_EXT_validation_cache ===
10637 
10638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10639     VULKAN_HPP_NODISCARD Result
10640       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
10641                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
10642                                 VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
10643                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10646     typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
10647       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo,
10648                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10649                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10650                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10651 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10653     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
10654       createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo,
10655                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10656                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10657                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10658 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10659 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10660 
10661     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10662     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
10663                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10664                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10665       VULKAN_HPP_NOEXCEPT;
10666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10667     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10668     void destroyValidationCacheEXT(
10669       VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10670       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10671                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10672       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10673 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10674 
10675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10676     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
10677                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10678                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10681     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10682                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10683                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10684                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10685 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10686 
10687     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10688     VULKAN_HPP_NODISCARD Result
10689       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
10690                                 uint32_t                                         srcCacheCount,
10691                                 const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
10692                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10695     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10696       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
10697                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
10698                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10699 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10700 
10701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10702     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(
10703       VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10704       size_t *                                 pDataSize,
10705       void *                                   pData,
10706       Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10707 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10708     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10709               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10710     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10711       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10712                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10713     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10714               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10715               typename B                = Uint8_tAllocator,
10716               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
10717     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10718       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10719                                  Uint8_tAllocator &                       uint8_tAllocator,
10720                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10721 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10722 
10723     //=== VK_NV_ray_tracing ===
10724 
10725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10726     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
10727       const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
10728       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
10729       VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
10730       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10733     typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
10734       createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo,
10735                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10736                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10737                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10738 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10739     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10740     VULKAN_HPP_INLINE
10741       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
10742       createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo,
10743                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10744                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10745                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10746 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10747 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10748 
10749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10750     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
10751                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10752                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10753       VULKAN_HPP_NOEXCEPT;
10754 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10755     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10756     void destroyAccelerationStructureNV(
10757       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10758       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10759                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10760       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10761 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10762 
10763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10764     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
10765                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10766                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10769     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10770                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10771                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10772                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10773 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10774 
10775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10776     void getAccelerationStructureMemoryRequirementsNV(
10777       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
10778       VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
10779       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10780 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10782     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
10783       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
10784       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10785     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10786     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
10787       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
10788       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10789 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10790 
10791     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10792     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(
10793       uint32_t                                                            bindInfoCount,
10794       const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
10795       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10798     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV(
10799       ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
10800       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10801 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10802 
10803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10804     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(
10805       VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10806       uint32_t                                                     createInfoCount,
10807       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
10808       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
10809       VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
10810       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10811 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10812     template <typename PipelineAllocator = std::allocator<Pipeline>,
10813               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10814     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10815                          createRayTracingPipelinesNV(
10816                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10817                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10818                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10819                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10820                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10821     template <typename PipelineAllocator = std::allocator<Pipeline>,
10822               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10823               typename B                 = PipelineAllocator,
10824               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
10825     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10826                          createRayTracingPipelinesNV(
10827                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10828                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10829                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                      allocator,
10830                            PipelineAllocator &                                                            pipelineAllocator,
10831                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10833     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
10834                          createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10835                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
10836                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10837                                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10838                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10839 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10840     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10841               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
10842     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10843                          createRayTracingPipelinesNVUnique(
10844                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10845                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10846                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10847                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10848                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10849     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10850               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
10851               typename B                         = PipelineAllocator,
10852               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
10853                                       int>::type = 0>
10854     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10855                          createRayTracingPipelinesNVUnique(
10856                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10857                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10858                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                      allocator,
10859                            PipelineAllocator &                                                            pipelineAllocator,
10860                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10862     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
10863                          createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10864                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
10865                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10866                                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10867                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10868 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10869 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10870 
10871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10872     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(
10873       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10874       uint32_t                       firstGroup,
10875       uint32_t                       groupCount,
10876       size_t                         dataSize,
10877       void *                         pData,
10878       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10879 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10880     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10881     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10882       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10883                                          uint32_t                       firstGroup,
10884                                          uint32_t                       groupCount,
10885                                          ArrayProxy<T> const &          data,
10886                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10887     template <typename T,
10888               typename Allocator = std::allocator<T>,
10889               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10890     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10891       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10892                                          uint32_t                       firstGroup,
10893                                          uint32_t                       groupCount,
10894                                          size_t                         dataSize,
10895                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10896     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10897     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10898       getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10899                                         uint32_t                       firstGroup,
10900                                         uint32_t                       groupCount,
10901                                         Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10902 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10903 
10904     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10905     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(
10906       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10907       size_t                                        dataSize,
10908       void *                                        pData,
10909       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10911     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10912     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10913       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10914                                         ArrayProxy<T> const &                         data,
10915                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10916     template <typename T,
10917               typename Allocator = std::allocator<T>,
10918               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10919     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10920       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10921                                         size_t                                        dataSize,
10922                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10923     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10924     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10925       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10926                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10927 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10928 
10929 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10931     VULKAN_HPP_NODISCARD Result
10932       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10933                          uint32_t                       shader,
10934                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10935 #else
10936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10937     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10938       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10939                          uint32_t                       shader,
10940                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10941 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10942 
10943     //=== VK_KHR_maintenance3 ===
10944 
10945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10946     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
10947                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
10948                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10949       VULKAN_HPP_NOEXCEPT;
10950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10952     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
10953       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
10954       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10955     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10956     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(
10957       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
10958       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10959 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10960 
10961     //=== VK_EXT_external_memory_host ===
10962 
10963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10964     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(
10965       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
10966       const void *                                           pHostPointer,
10967       VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
10968       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10969 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10970     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10971     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10972       typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
10973       getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
10974                                          const void *                                           pHostPointer,
10975                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10976 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10977 
10978     //=== VK_EXT_calibrated_timestamps ===
10979 
10980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10981     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(
10982       uint32_t                                                 timestampCount,
10983       const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
10984       uint64_t *                                               pTimestamps,
10985       uint64_t *                                               pMaxDeviation,
10986       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10987 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10988     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10989     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
10990       ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
10991       ArrayProxy<uint64_t> const &                                               timestamps,
10992       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10993     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
10994               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10995     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10996       typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
10997       getCalibratedTimestampsEXT(
10998         ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
10999         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11000     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
11001               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11002               typename B                 = Uint64_tAllocator,
11003               typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type = 0>
11004     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11005       typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
11006       getCalibratedTimestampsEXT(
11007         ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
11008         Uint64_tAllocator &                                                        uint64_tAllocator,
11009         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11011     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
11012       getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo,
11013                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11014 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11015 
11016     //=== VK_KHR_timeline_semaphore ===
11017 
11018     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11019     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(
11020       VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11021       uint64_t *                      pValue,
11022       Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11023 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11025     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
11026       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11027                                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11028 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11029 
11030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11031     VULKAN_HPP_NODISCARD Result
11032       waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
11033                          uint64_t                                        timeout,
11034                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11035 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11036     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11037     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
11038                                                    uint64_t                                        timeout,
11039                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11040 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11041 
11042     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11043     VULKAN_HPP_NODISCARD Result
11044       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
11045                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11046 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11048     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11049       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo,
11050                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11051 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11052 
11053     //=== VK_INTEL_performance_query ===
11054 
11055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11056     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(
11057       const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
11058       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11061     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11062       initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,
11063                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11064 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11065 
11066     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11067     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11068       VULKAN_HPP_NOEXCEPT;
11069 
11070     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11071     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(
11072       const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
11073       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
11074       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11075 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11076     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11077     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11078       typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
11079       acquirePerformanceConfigurationINTEL(
11080         const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
11081         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11082 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11083     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11084     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11085       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
11086       acquirePerformanceConfigurationINTELUnique(
11087         const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
11088         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11089 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11090 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11091 
11092 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11094     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(
11095       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
11096       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11097 #else
11098     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11099     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL(
11100       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11101       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11102 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11103 
11104 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11106     VULKAN_HPP_NODISCARD Result
11107       release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
11108                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11109 #else
11110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11111     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11112       release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
11113                Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11114 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11115 
11116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11117     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(
11118       VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
11119       VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
11120       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11123     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
11124       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
11125                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11126 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11127 
11128     //=== VK_AMD_display_native_hdr ===
11129 
11130     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11131     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
11132                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
11133                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11134 
11135     //=== VK_EXT_buffer_device_address ===
11136 
11137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11138     DeviceAddress
11139       getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11140                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11143     DeviceAddress
11144       getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11145                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11146 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11147 
11148     //=== VK_KHR_present_wait ===
11149 
11150 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11151     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11152     VULKAN_HPP_NODISCARD Result
11153       waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11154                          uint64_t                           presentId,
11155                          uint64_t                           timeout,
11156                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11157 #else
11158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11159     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11160                                                    uint64_t                           presentId,
11161                                                    uint64_t                           timeout,
11162                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11163 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11164 
11165 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11166     //=== VK_EXT_full_screen_exclusive ===
11167 
11168 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11170     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(
11171       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11172       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11173 #  else
11174     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11175     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11176       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11177                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11178 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11179 
11180 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11181     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11182     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(
11183       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11184       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11185 #  else
11186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11187     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11188       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11189                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11190 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11191 
11192     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11193     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT(
11194       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
11195       VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
11196       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11197 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11199     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11200       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
11201       getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
11202                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11203 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11204 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11205 
11206     //=== VK_KHR_buffer_device_address ===
11207 
11208     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11209     DeviceAddress
11210       getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11211                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11214     DeviceAddress
11215       getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11216                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11217 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11218 
11219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11220     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11221                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11222       VULKAN_HPP_NOEXCEPT;
11223 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11225     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11226                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11227       VULKAN_HPP_NOEXCEPT;
11228 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11229 
11230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11231     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
11232                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11233       VULKAN_HPP_NOEXCEPT;
11234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11236     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
11237                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11238       VULKAN_HPP_NOEXCEPT;
11239 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11240 
11241     //=== VK_EXT_host_query_reset ===
11242 
11243     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11244     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
11245                             uint32_t                        firstQuery,
11246                             uint32_t                        queryCount,
11247                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11248 
11249     //=== VK_KHR_deferred_host_operations ===
11250 
11251     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11252     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
11253       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11254       VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
11255       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11256 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11258     typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
11259       createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11260                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11261                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11262 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11263     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11264     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
11265       createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11266                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11267                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11268 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11269 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11270 
11271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11272     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
11273                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11274                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11275       VULKAN_HPP_NOEXCEPT;
11276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11278     void destroyDeferredOperationKHR(
11279       VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11280       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11281                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11282       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11283 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11284 
11285     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11286     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
11287                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11288                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11289 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11291     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11292                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11293                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11294                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11295 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11296 
11297     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11298     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11299                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11300       VULKAN_HPP_NOEXCEPT;
11301 
11302 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11304     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(
11305       VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11306       Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11307 #else
11308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11309     VULKAN_HPP_NODISCARD Result
11310       getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11311                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11312 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11313 
11314 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11316     VULKAN_HPP_NODISCARD Result
11317       deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11318                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11319 #else
11320     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11321     VULKAN_HPP_NODISCARD Result
11322       deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11323                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11324 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11325 
11326     //=== VK_KHR_pipeline_executable_properties ===
11327 
11328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11329     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(
11330       const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
11331       uint32_t *                                              pExecutableCount,
11332       VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
11333       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11335     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
11336               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11337     VULKAN_HPP_NODISCARD typename ResultValueType<
11338       std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
11339       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
11340                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11341     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
11342               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11343               typename B                                        = PipelineExecutablePropertiesKHRAllocator,
11344               typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
11345                                       int>::type                = 0>
11346     VULKAN_HPP_NODISCARD typename ResultValueType<
11347       std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
11348       getPipelineExecutablePropertiesKHR(
11349         const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
11350         PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,
11351         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11352 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11353 
11354     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11355     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(
11356       const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
11357       uint32_t *                                              pStatisticCount,
11358       VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
11359       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11361     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
11362               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11363     VULKAN_HPP_NODISCARD typename ResultValueType<
11364       std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
11365       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11366                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11367     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
11368               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11369               typename B                                       = PipelineExecutableStatisticKHRAllocator,
11370               typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
11371                                       int>::type               = 0>
11372     VULKAN_HPP_NODISCARD typename ResultValueType<
11373       std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
11374       getPipelineExecutableStatisticsKHR(
11375         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11376         PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,
11377         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11378 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11379 
11380     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11381     VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(
11382       const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
11383       uint32_t *                                                          pInternalRepresentationCount,
11384       VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
11385       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11386 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11387     template <typename PipelineExecutableInternalRepresentationKHRAllocator =
11388                 std::allocator<PipelineExecutableInternalRepresentationKHR>,
11389               typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11390     VULKAN_HPP_NODISCARD
11391       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
11392                                            PipelineExecutableInternalRepresentationKHRAllocator>>::type
11393       getPipelineExecutableInternalRepresentationsKHR(
11394         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11395         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11396     template <
11397       typename PipelineExecutableInternalRepresentationKHRAllocator =
11398         std::allocator<PipelineExecutableInternalRepresentationKHR>,
11399       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11400       typename B                         = PipelineExecutableInternalRepresentationKHRAllocator,
11401       typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
11402                               int>::type = 0>
11403     VULKAN_HPP_NODISCARD
11404       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
11405                                            PipelineExecutableInternalRepresentationKHRAllocator>>::type
11406       getPipelineExecutableInternalRepresentationsKHR(
11407         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11408         PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,
11409         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11410 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11411 
11412     //=== VK_NV_device_generated_commands ===
11413 
11414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11415     void getGeneratedCommandsMemoryRequirementsNV(
11416       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
11417       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
11418       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11419 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11420     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11421     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
11422       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
11423       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11424     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11425     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
11426       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
11427       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11428 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11429 
11430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11431     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(
11432       const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
11433       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
11434       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,
11435       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11436 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11437     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11438     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11439       typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
11440       createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo,
11441                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11442                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11443                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11444 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11446     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11447       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
11448       createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo,
11449                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11450                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11451                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11452 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11453 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11454 
11455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11456     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
11457                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11458                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11459       VULKAN_HPP_NOEXCEPT;
11460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11461     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11462     void destroyIndirectCommandsLayoutNV(
11463       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11464       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11465                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11466       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11467 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11468 
11469     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11470     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
11471                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11472                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11473 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11475     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
11476                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11477                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11478                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11479 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11480 
11481     //=== VK_EXT_private_data ===
11482 
11483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11484     VULKAN_HPP_NODISCARD Result
11485       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo,
11486                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
11487                                 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT *                 pPrivateDataSlot,
11488                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11491     typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::type
11492       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT & createInfo,
11493                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11494                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11495                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11496 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11498     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type
11499       createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT & createInfo,
11500                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11501                                                          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 destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
11508                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11509                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11510       VULKAN_HPP_NOEXCEPT;
11511 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11512     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11513     void destroyPrivateDataSlotEXT(
11514       VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11515       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11516                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11517       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11518 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11519 
11520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11521     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
11522                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11523                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11526     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11527                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11528                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11529                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11530 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11531 
11532 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11534     VULKAN_HPP_NODISCARD Result
11535       setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11536                          uint64_t                                 objectHandle,
11537                          VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11538                          uint64_t                                 data,
11539                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11540 #else
11541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11542     typename ResultValueType<void>::type
11543          setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11544                             uint64_t                                 objectHandle,
11545                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11546                             uint64_t                                 data,
11547                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11548 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11549 
11550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11551     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11552                             uint64_t                                 objectHandle,
11553                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11554                             uint64_t *                               pData,
11555                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11556 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11558     VULKAN_HPP_NODISCARD uint64_t
11559       getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11560                          uint64_t                                 objectHandle,
11561                          VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11562                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11563 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11564 
11565     //=== VK_KHR_ray_tracing_pipeline ===
11566 
11567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11568     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(
11569       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
11570       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
11571       uint32_t                                                      createInfoCount,
11572       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
11573       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,
11574       VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,
11575       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11577     template <typename PipelineAllocator = std::allocator<Pipeline>,
11578               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11579     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11580                          createRayTracingPipelinesKHR(
11581                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11582                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11583                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11584                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11585                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11586                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11587     template <typename PipelineAllocator = std::allocator<Pipeline>,
11588               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11589               typename B                 = PipelineAllocator,
11590               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
11591     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11592                          createRayTracingPipelinesKHR(
11593                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11594                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11595                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11596                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                       allocator,
11597                            PipelineAllocator &                                                             pipelineAllocator,
11598                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11599     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11600     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
11601                          createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
11602                                                       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
11603                                                       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
11604                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11605                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11606                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11607 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11608     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11609               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
11610     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
11611                          createRayTracingPipelinesKHRUnique(
11612                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11613                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11614                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11615                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11616                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11617                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11618     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11619               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
11620               typename B                         = PipelineAllocator,
11621               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
11622                                       int>::type = 0>
11623     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
11624                          createRayTracingPipelinesKHRUnique(
11625                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11626                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11627                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11628                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                       allocator,
11629                            PipelineAllocator &                                                             pipelineAllocator,
11630                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11631     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11632     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
11633       createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11634                                          VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
11635                                          const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
11636                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11637                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11638                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11639 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11640 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11641 
11642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11643     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(
11644       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11645       uint32_t                       firstGroup,
11646       uint32_t                       groupCount,
11647       size_t                         dataSize,
11648       void *                         pData,
11649       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11651     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11652     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11653       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11654                                           uint32_t                       firstGroup,
11655                                           uint32_t                       groupCount,
11656                                           ArrayProxy<T> const &          data,
11657                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11658     template <typename T,
11659               typename Allocator = std::allocator<T>,
11660               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11661     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
11662       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11663                                           uint32_t                       firstGroup,
11664                                           uint32_t                       groupCount,
11665                                           size_t                         dataSize,
11666                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11667     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11668     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
11669       getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11670                                          uint32_t                       firstGroup,
11671                                          uint32_t                       groupCount,
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     VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
11677       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11678       uint32_t                       firstGroup,
11679       uint32_t                       groupCount,
11680       size_t                         dataSize,
11681       void *                         pData,
11682       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11683 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11684     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11685     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11686       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11687                                                        uint32_t                       firstGroup,
11688                                                        uint32_t                       groupCount,
11689                                                        ArrayProxy<T> const &          data,
11690                                                        Dispatch const & d
11691                                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11692     template <typename T,
11693               typename Allocator = std::allocator<T>,
11694               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11695     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
11696       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11697                                                        uint32_t                       firstGroup,
11698                                                        uint32_t                       groupCount,
11699                                                        size_t                         dataSize,
11700                                                        Dispatch const & d
11701                                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11702     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11703     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
11704       getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11705                                                       uint32_t                       firstGroup,
11706                                                       uint32_t                       groupCount,
11707                                                       Dispatch const & d
11708                                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11709 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11710 
11711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11712     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
11713                                                      uint32_t                                   group,
11714                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
11715                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11716       VULKAN_HPP_NOEXCEPT;
11717 
11718 #if defined( VK_USE_PLATFORM_FUCHSIA )
11719     //=== VK_FUCHSIA_external_memory ===
11720 
11721     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11722     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA(
11723       const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11724       zx_handle_t *                                                  pZirconHandle,
11725       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11726 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11728     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
11729       getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11730                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11731 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11732 
11733     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11734     VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA(
11735       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
11736       zx_handle_t                                                 zirconHandle,
11737       VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
11738       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11739 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11740     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11741     typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
11742       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11743                                               zx_handle_t                                            zirconHandle,
11744                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11745 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11746 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11747 
11748 #if defined( VK_USE_PLATFORM_FUCHSIA )
11749     //=== VK_FUCHSIA_external_semaphore ===
11750 
11751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11752     VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA(
11753       const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
11754       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11755 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11756     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11757     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA(
11758       const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
11759       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11760 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11761 
11762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11763     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA(
11764       const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11765       zx_handle_t *                                                     pZirconHandle,
11766       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11767 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11769     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type getSemaphoreZirconHandleFUCHSIA(
11770       const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11771       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11772 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11773 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11774 
11775 #if defined( VK_USE_PLATFORM_FUCHSIA )
11776     //=== VK_FUCHSIA_buffer_collection ===
11777 
11778     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11779     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA(
11780       const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
11781       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
11782       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,
11783       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11784 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11785     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11786     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11787       typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type
11788       createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
11789                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11790                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11791                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11792 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
11793     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11794     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11795       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type
11796       createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
11797                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11798                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11799                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11800 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11801 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11802 
11803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11804     VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIA(
11805       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
11806       const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
11807       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11808 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11809     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11810     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11811       setBufferCollectionImageConstraintsFUCHSIA(
11812         VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
11813         const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
11814         Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11815 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11816 
11817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11818     VULKAN_HPP_NODISCARD Result setBufferCollectionBufferConstraintsFUCHSIA(
11819       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
11820       const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
11821       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11822 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11824     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11825       setBufferCollectionBufferConstraintsFUCHSIA(
11826         VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
11827         const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
11828         Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11829 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11830 
11831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11832     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
11833                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11834                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11835       VULKAN_HPP_NOEXCEPT;
11836 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11838     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11839                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11840                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11841                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11842       VULKAN_HPP_NOEXCEPT;
11843 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11844 
11845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11846     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
11847                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11848                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11849 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11851     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11852                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11853                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11854                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11855 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11856 
11857     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11858     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA(
11859       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
11860       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
11861       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11862 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11864     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11865       typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type
11866       getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11867                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11868 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11869 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11870 
11871     //=== VK_HUAWEI_subpass_shading ===
11872 
11873     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11874     VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(
11875       VULKAN_HPP_NAMESPACE::RenderPass renderpass,
11876       VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
11877       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11880     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>
11881                          getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
11882                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11883 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11884 
11885     //=== VK_NV_external_memory_rdma ===
11886 
11887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11888     VULKAN_HPP_NODISCARD Result
11889       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
11890                                 VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,
11891                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11892 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11893     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11894     typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
11895       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
11896                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11897 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11898 
11899     //=== VK_EXT_pageable_device_local_memory ===
11900 
11901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11902     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
11903                                float                              priority,
11904                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11905 
11906     //=== VK_KHR_maintenance4 ===
11907 
11908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11909     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR * pInfo,
11910                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11911                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11912       VULKAN_HPP_NOEXCEPT;
11913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11915     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR(
11916       const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info,
11917       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11918     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11919     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR(
11920       const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info,
11921       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11922 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11923 
11924     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11925     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR * pInfo,
11926                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11927                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11928       VULKAN_HPP_NOEXCEPT;
11929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11931     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR(
11932       const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
11933       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11934     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11935     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR(
11936       const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
11937       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11938 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11939 
11940     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11941     void getImageSparseMemoryRequirementsKHR(
11942       const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR * pInfo,
11943       uint32_t *                                                     pSparseMemoryRequirementCount,
11944       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *         pSparseMemoryRequirements,
11945       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11947     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
11948               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11949     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11950       getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
11951                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11952     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
11953               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11954               typename B                                       = SparseImageMemoryRequirements2Allocator,
11955               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
11956                                       int>::type               = 0>
11957     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11958                          getImageSparseMemoryRequirementsKHR(
11959                            const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
11960                            SparseImageMemoryRequirements2Allocator &                      sparseImageMemoryRequirements2Allocator,
11961                            Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11962 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11963 
operator VkDevice() const11964     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const VULKAN_HPP_NOEXCEPT
11965     {
11966       return m_device;
11967     }
11968 
operator bool() const11969     explicit operator bool() const VULKAN_HPP_NOEXCEPT
11970     {
11971       return m_device != VK_NULL_HANDLE;
11972     }
11973 
operator !() const11974     bool operator!() const VULKAN_HPP_NOEXCEPT
11975     {
11976       return m_device == VK_NULL_HANDLE;
11977     }
11978 
11979   private:
11980     VkDevice m_device = {};
11981   };
11982   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ),
11983                             "handle and wrapper have different size!" );
11984   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Device>::value,
11985                             "Device is not nothrow_move_constructible!" );
11986 
11987   template <>
11988   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDevice>
11989   {
11990     using type = VULKAN_HPP_NAMESPACE::Device;
11991   };
11992 
11993   template <>
11994   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
11995   {
11996     using Type = VULKAN_HPP_NAMESPACE::Device;
11997   };
11998 
11999   template <>
12000   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
12001                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
12002   {
12003     using Type = VULKAN_HPP_NAMESPACE::Device;
12004   };
12005 
12006   template <>
12007   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
12008   {
12009     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12010   };
12011 
12012   class DisplayModeKHR
12013   {
12014   public:
12015     using CType      = VkDisplayModeKHR;
12016     using NativeType = VkDisplayModeKHR;
12017 
12018     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
12019       VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
12020     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
12021       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
12022 
12023   public:
12024     VULKAN_HPP_CONSTEXPR         DisplayModeKHR() = default;
DisplayModeKHR(std::nullptr_t)12025     VULKAN_HPP_CONSTEXPR         DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)12026     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
12027       : m_displayModeKHR( displayModeKHR )
12028     {}
12029 
12030 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayModeKHR displayModeKHR)12031     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
12032     {
12033       m_displayModeKHR = displayModeKHR;
12034       return *this;
12035     }
12036 #endif
12037 
operator =(std::nullptr_t)12038     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12039     {
12040       m_displayModeKHR = {};
12041       return *this;
12042     }
12043 
12044 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12045     auto operator<=>( DisplayModeKHR const & ) const = default;
12046 #else
operator ==(DisplayModeKHR const & rhs) const12047     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
12048     {
12049       return m_displayModeKHR == rhs.m_displayModeKHR;
12050     }
12051 
operator !=(DisplayModeKHR const & rhs) const12052     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
12053     {
12054       return m_displayModeKHR != rhs.m_displayModeKHR;
12055     }
12056 
operator <(DisplayModeKHR const & rhs) const12057     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
12058     {
12059       return m_displayModeKHR < rhs.m_displayModeKHR;
12060     }
12061 #endif
12062 
operator VkDisplayModeKHR() const12063     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
12064     {
12065       return m_displayModeKHR;
12066     }
12067 
operator bool() const12068     explicit operator bool() const VULKAN_HPP_NOEXCEPT
12069     {
12070       return m_displayModeKHR != VK_NULL_HANDLE;
12071     }
12072 
operator !() const12073     bool operator!() const VULKAN_HPP_NOEXCEPT
12074     {
12075       return m_displayModeKHR == VK_NULL_HANDLE;
12076     }
12077 
12078   private:
12079     VkDisplayModeKHR m_displayModeKHR = {};
12080   };
12081   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ),
12082                             "handle and wrapper have different size!" );
12083   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::value,
12084                             "DisplayModeKHR is not nothrow_move_constructible!" );
12085 
12086   template <>
12087   struct VULKAN_HPP_DEPRECATED(
12088     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayModeKHR>
12089   {
12090     using type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
12091   };
12092 
12093   template <>
12094   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
12095   {
12096     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
12097   };
12098 
12099   template <>
12100   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
12101                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
12102   {
12103     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
12104   };
12105 
12106   template <>
12107   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
12108   {
12109     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12110   };
12111 
12112 #ifndef VULKAN_HPP_NO_SMART_HANDLE
12113   template <typename Dispatch>
12114   class UniqueHandleTraits<Device, Dispatch>
12115   {
12116   public:
12117     using deleter = ObjectDestroy<NoParent, Dispatch>;
12118   };
12119   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
12120 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12121 
12122   class PhysicalDevice
12123   {
12124   public:
12125     using CType      = VkPhysicalDevice;
12126     using NativeType = VkPhysicalDevice;
12127 
12128     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
12129       VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
12130     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
12131       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
12132 
12133   public:
12134     VULKAN_HPP_CONSTEXPR         PhysicalDevice() = default;
PhysicalDevice(std::nullptr_t)12135     VULKAN_HPP_CONSTEXPR         PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PhysicalDevice(VkPhysicalDevice physicalDevice)12136     VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
12137       : m_physicalDevice( physicalDevice )
12138     {}
12139 
12140 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPhysicalDevice physicalDevice)12141     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
12142     {
12143       m_physicalDevice = physicalDevice;
12144       return *this;
12145     }
12146 #endif
12147 
operator =(std::nullptr_t)12148     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12149     {
12150       m_physicalDevice = {};
12151       return *this;
12152     }
12153 
12154 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12155     auto operator<=>( PhysicalDevice const & ) const = default;
12156 #else
operator ==(PhysicalDevice const & rhs) const12157     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
12158     {
12159       return m_physicalDevice == rhs.m_physicalDevice;
12160     }
12161 
operator !=(PhysicalDevice const & rhs) const12162     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
12163     {
12164       return m_physicalDevice != rhs.m_physicalDevice;
12165     }
12166 
operator <(PhysicalDevice const & rhs) const12167     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
12168     {
12169       return m_physicalDevice < rhs.m_physicalDevice;
12170     }
12171 #endif
12172 
12173     //=== VK_VERSION_1_0 ===
12174 
12175     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12176     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
12177                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12178 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12179     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12180     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
12181       getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12182 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12183 
12184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12185     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
12186                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
12187                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12189     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12190     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
12191                          getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
12192                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12193 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12194 
12195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12196     VULKAN_HPP_NODISCARD Result
12197       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
12198                                 VULKAN_HPP_NAMESPACE::ImageType               type,
12199                                 VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
12200                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
12201                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
12202                                 VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
12203                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12204 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12206     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
12207       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
12208                                 VULKAN_HPP_NAMESPACE::ImageType              type,
12209                                 VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
12210                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
12211                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12212                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12213 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12214 
12215     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12216     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
12217                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12220     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
12221       getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12222 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12223 
12224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12225     void
12226       getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
12227                                 VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
12228                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12230     template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
12231               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12232     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
12233                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12234     template <
12235       typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
12236       typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12237       typename B                              = QueueFamilyPropertiesAllocator,
12238       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
12239     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
12240                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
12241                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12242 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12243 
12244     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12245     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
12246                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12249     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
12250       getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12251 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12252 
12253     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12254     VULKAN_HPP_NODISCARD Result
12255       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
12256                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12257                     VULKAN_HPP_NAMESPACE::Device *                    pDevice,
12258                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12261     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
12262       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo,
12263                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12264                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12265                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12266 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12267     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12268     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12269       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
12270       createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo,
12271                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12272                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12273                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12274 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12275 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12276 
12277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12278     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(
12279       const char *                                pLayerName,
12280       uint32_t *                                  pPropertyCount,
12281       VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
12282       Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12284     template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
12285               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12286     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
12287       enumerateDeviceExtensionProperties( Optional<const std::string> layerName
12288                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12289                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12290     template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
12291               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12292               typename B                            = ExtensionPropertiesAllocator,
12293               typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
12294     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
12295       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
12296                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
12297                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12298 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12299 
12300     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12301     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(
12302       uint32_t *                              pPropertyCount,
12303       VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
12304       Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12306     template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
12307               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12308     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
12309       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12310     template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
12311               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12312               typename B                        = LayerPropertiesAllocator,
12313               typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
12314     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
12315       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
12316                                       Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12317 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12318 
12319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12320     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
12321                                          VULKAN_HPP_NAMESPACE::ImageType                     type,
12322                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
12323                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
12324                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
12325                                          uint32_t *                                          pPropertyCount,
12326                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
12327                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12328       VULKAN_HPP_NOEXCEPT;
12329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12330     template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
12331               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12332     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
12333                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
12334                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
12335                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
12336                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
12337                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
12338                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12339     template <
12340       typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
12341       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12342       typename B                                    = SparseImageFormatPropertiesAllocator,
12343       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
12344     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
12345                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
12346                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
12347                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
12348                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
12349                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
12350                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
12351                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12352 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12353 
12354     //=== VK_VERSION_1_1 ===
12355 
12356     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12357     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
12358                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12361     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
12362       getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12363     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12364     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12365       getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12366 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12367 
12368     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12369     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
12370                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12371 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12372     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12373     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
12374       getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12375     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12376     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12377       getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12378 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12379 
12380     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12381     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
12382                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
12383                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12385     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12386     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
12387                          getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
12388                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12389     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12390     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12391                          getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
12392                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12393 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12394 
12395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12396     VULKAN_HPP_NODISCARD Result getImageFormatProperties2(
12397       const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
12398       VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
12399       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12402     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
12403       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12404                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12405     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12406     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12407       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12408                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12409 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12410 
12411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12412     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
12413                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
12414                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12415       VULKAN_HPP_NOEXCEPT;
12416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12417     template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12418               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12419     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12420                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12421     template <
12422       typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12423       typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12424       typename B                               = QueueFamilyProperties2Allocator,
12425       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
12426     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12427                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
12428                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12429     template <typename StructureChain,
12430               typename StructureChainAllocator = std::allocator<StructureChain>,
12431               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12432     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12433                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12434     template <typename StructureChain,
12435               typename StructureChainAllocator = std::allocator<StructureChain>,
12436               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12437               typename B                       = StructureChainAllocator,
12438               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
12439     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12440                          getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
12441                                                     Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12442 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12443 
12444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12445     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
12446                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12449     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
12450       getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12451     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12452     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12453       getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12454 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12455 
12456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12457     void getSparseImageFormatProperties2(
12458       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
12459       uint32_t *                                                         pPropertyCount,
12460       VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
12461       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12463     template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12464               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12465     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12466       getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12467                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12468     template <
12469       typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12470       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12471       typename B                                     = SparseImageFormatProperties2Allocator,
12472       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
12473     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12474       getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12475                                        SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
12476                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12477 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12478 
12479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12480     void getExternalBufferProperties(
12481       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
12482       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
12483       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12484 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12485     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12486     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
12487       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
12488       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12489 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12490 
12491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12492     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
12493                                      VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
12494                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12495       VULKAN_HPP_NOEXCEPT;
12496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12498     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
12499       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
12500       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12501 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12502 
12503     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12504     void getExternalSemaphoreProperties(
12505       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
12506       VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
12507       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12510     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
12511       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
12512       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12513 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12514 
12515     //=== VK_KHR_surface ===
12516 
12517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12518     VULKAN_HPP_NODISCARD Result
12519       getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
12520                             VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12521                             VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
12522                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12523 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12525     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
12526       getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
12527                             VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12528                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12529 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12530 
12531     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12532     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(
12533       VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
12534       VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
12535       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12538     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
12539       getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12540                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12541 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12542 
12543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12544     VULKAN_HPP_NODISCARD Result
12545       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
12546                             uint32_t *                               pSurfaceFormatCount,
12547                             VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
12548                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12550     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
12551               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12552     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
12553       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12554                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12555     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
12556               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12557               typename B                         = SurfaceFormatKHRAllocator,
12558               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
12559     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
12560       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12561                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
12562                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12563 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12564 
12565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12566     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(
12567       VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
12568       uint32_t *                             pPresentModeCount,
12569       VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
12570       Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12571 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12572     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
12573               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12574     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
12575       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12576                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12577     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
12578               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12579               typename B                       = PresentModeKHRAllocator,
12580               typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
12581     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
12582       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12583                                  PresentModeKHRAllocator &        presentModeKHRAllocator,
12584                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12585 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12586 
12587     //=== VK_KHR_swapchain ===
12588 
12589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12590     VULKAN_HPP_NODISCARD Result
12591       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12592                                uint32_t *                       pRectCount,
12593                                VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
12594                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12595 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12596     template <typename Rect2DAllocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12597     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
12598       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12599                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12600     template <typename Rect2DAllocator = std::allocator<Rect2D>,
12601               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12602               typename B               = Rect2DAllocator,
12603               typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
12604     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
12605       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12606                                Rect2DAllocator &                rect2DAllocator,
12607                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12608 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12609 
12610     //=== VK_KHR_display ===
12611 
12612     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12613     VULKAN_HPP_NODISCARD Result
12614       getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
12615                                VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
12616                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12617 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12618     template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
12619               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12620     VULKAN_HPP_NODISCARD
12621       typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
12622       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12623     template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
12624               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12625               typename B                             = DisplayPropertiesKHRAllocator,
12626               typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
12627     VULKAN_HPP_NODISCARD
12628       typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
12629       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
12630                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12631 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12632 
12633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12634     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(
12635       uint32_t *                                        pPropertyCount,
12636       VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
12637       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12639     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
12640               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12641     VULKAN_HPP_NODISCARD
12642       typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
12643       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12644     template <
12645       typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
12646       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12647       typename B                                  = DisplayPlanePropertiesKHRAllocator,
12648       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
12649     VULKAN_HPP_NODISCARD
12650       typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
12651       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
12652                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12653 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12654 
12655     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12656     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(
12657       uint32_t                           planeIndex,
12658       uint32_t *                         pDisplayCount,
12659       VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
12660       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12662     template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
12663               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12664     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
12665       getDisplayPlaneSupportedDisplaysKHR( uint32_t           planeIndex,
12666                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12667     template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
12668               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12669               typename B                   = DisplayKHRAllocator,
12670               typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
12671     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
12672       getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
12673                                            DisplayKHRAllocator & displayKHRAllocator,
12674                                            Dispatch const & d    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12675 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12676 
12677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12678     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(
12679       VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
12680       uint32_t *                                       pPropertyCount,
12681       VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
12682       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12683 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12684     template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
12685               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12686     VULKAN_HPP_NODISCARD
12687       typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
12688       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12689                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12690     template <
12691       typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
12692       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12693       typename B                                 = DisplayModePropertiesKHRAllocator,
12694       typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
12695     VULKAN_HPP_NODISCARD
12696       typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
12697       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
12698                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
12699                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12700 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12701 
12702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12703     VULKAN_HPP_NODISCARD Result
12704       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
12705                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
12706                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
12707                             VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
12708                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12709 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12711     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
12712       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
12713                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo,
12714                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12715                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12716                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12717 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12719     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12720       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
12721       createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
12722                                   const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo,
12723                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12724                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12725                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12726 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12727 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12728 
12729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12730     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(
12731       VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
12732       uint32_t                                            planeIndex,
12733       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
12734       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12735 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12737     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12738       typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
12739       getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
12740                                       uint32_t                             planeIndex,
12741                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12742 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12743 
12744 #if defined( VK_USE_PLATFORM_XLIB_KHR )
12745     //=== VK_KHR_xlib_surface ===
12746 
12747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12748     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
12749                                           Display *          dpy,
12750                                           VisualID           visualID,
12751                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12752       VULKAN_HPP_NOEXCEPT;
12753 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12754     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12755     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
12756                                           Display &          dpy,
12757                                           VisualID           visualID,
12758                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12759       VULKAN_HPP_NOEXCEPT;
12760 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12761 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/
12762 
12763 #if defined( VK_USE_PLATFORM_XCB_KHR )
12764     //=== VK_KHR_xcb_surface ===
12765 
12766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12767     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
12768                                          xcb_connection_t * connection,
12769                                          xcb_visualid_t     visual_id,
12770                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12771       VULKAN_HPP_NOEXCEPT;
12772 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12774     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
12775                                          xcb_connection_t & connection,
12776                                          xcb_visualid_t     visual_id,
12777                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12778       VULKAN_HPP_NOEXCEPT;
12779 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12780 #endif   /*VK_USE_PLATFORM_XCB_KHR*/
12781 
12782 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
12783     //=== VK_KHR_wayland_surface ===
12784 
12785     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12786     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
12787                                              struct wl_display * display,
12788                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12789       VULKAN_HPP_NOEXCEPT;
12790 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12791     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12792     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
12793                                              struct wl_display & display,
12794                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12795       VULKAN_HPP_NOEXCEPT;
12796 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12797 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
12798 
12799 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12800     //=== VK_KHR_win32_surface ===
12801 
12802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12803     Bool32 getWin32PresentationSupportKHR( uint32_t           queueFamilyIndex,
12804                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12805       VULKAN_HPP_NOEXCEPT;
12806 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12807 
12808 #if defined( VK_ENABLE_BETA_EXTENSIONS )
12809     //=== VK_KHR_video_queue ===
12810 
12811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12812     VULKAN_HPP_NODISCARD Result
12813       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
12814                                VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
12815                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12816 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12818     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
12819       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile,
12820                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12821     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12822     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12823       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile,
12824                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12825 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12826 
12827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12828     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(
12829       const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
12830       uint32_t *                                                     pVideoFormatPropertyCount,
12831       VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
12832       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12833 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12834     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
12835               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12836     VULKAN_HPP_NODISCARD
12837       typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
12838       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
12839                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12840     template <
12841       typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
12842       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12843       typename B                                 = VideoFormatPropertiesKHRAllocator,
12844       typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
12845     VULKAN_HPP_NODISCARD
12846       typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
12847       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
12848                                    VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
12849                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12850 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12851 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
12852 
12853     //=== VK_NV_external_memory_capabilities ===
12854 
12855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12856     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(
12857       VULKAN_HPP_NAMESPACE::Format                            format,
12858       VULKAN_HPP_NAMESPACE::ImageType                         type,
12859       VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
12860       VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
12861       VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
12862       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
12863       VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
12864       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12867     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12868       typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
12869       getExternalImageFormatPropertiesNV(
12870         VULKAN_HPP_NAMESPACE::Format                                             format,
12871         VULKAN_HPP_NAMESPACE::ImageType                                          type,
12872         VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
12873         VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
12874         VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12875         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12876         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12877 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12878 
12879     //=== VK_KHR_get_physical_device_properties2 ===
12880 
12881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12882     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
12883                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12886     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
12887       getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12888     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12889     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12890       getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12891 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12892 
12893     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12894     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
12895                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12898     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
12899       getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12900     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12901     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12902       getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12903 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12904 
12905     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12906     void
12907       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
12908                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
12909                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12911     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12912     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
12913                          getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
12914                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12915     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12916     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12917                          getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
12918                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12919 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12920 
12921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12922     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(
12923       const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
12924       VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
12925       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12926 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12928     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
12929       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12930                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12931     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12932     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12933       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12934                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12935 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12936 
12937     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12938     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
12939                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
12940                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12941       VULKAN_HPP_NOEXCEPT;
12942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12943     template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12944               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12945     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12946       getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12947     template <
12948       typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12949       typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12950       typename B                               = QueueFamilyProperties2Allocator,
12951       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
12952     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12953       getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
12954                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12955     template <typename StructureChain,
12956               typename StructureChainAllocator = std::allocator<StructureChain>,
12957               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12958     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12959       getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12960     template <typename StructureChain,
12961               typename StructureChainAllocator = std::allocator<StructureChain>,
12962               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12963               typename B                       = StructureChainAllocator,
12964               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
12965     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12966                          getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
12967                                                        Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12968 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12969 
12970     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12971     void
12972       getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
12973                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12974 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12976     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
12977       getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12978     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12979     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12980       getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12981 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12982 
12983     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12984     void getSparseImageFormatProperties2KHR(
12985       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
12986       uint32_t *                                                         pPropertyCount,
12987       VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
12988       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12990     template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12991               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12992     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12993       getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12994                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12995     template <
12996       typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12997       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12998       typename B                                     = SparseImageFormatProperties2Allocator,
12999       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
13000     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13001       getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
13002                                           SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
13003                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13004 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13005 
13006     //=== VK_KHR_external_memory_capabilities ===
13007 
13008     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13009     void getExternalBufferPropertiesKHR(
13010       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
13011       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
13012       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13015     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
13016       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
13017       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13018 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13019 
13020     //=== VK_KHR_external_semaphore_capabilities ===
13021 
13022     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13023     void getExternalSemaphorePropertiesKHR(
13024       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
13025       VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
13026       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13029     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
13030       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
13031       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13032 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13033 
13034     //=== VK_EXT_direct_mode_display ===
13035 
13036 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13038     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13039                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13040 #else
13041     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13042     typename ResultValueType<void>::type
13043       releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13044                          Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13045 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13046 
13047 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
13048     //=== VK_EXT_acquire_xlib_display ===
13049 
13050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13051     VULKAN_HPP_NODISCARD Result
13052       acquireXlibDisplayEXT( Display *                        dpy,
13053                              VULKAN_HPP_NAMESPACE::DisplayKHR display,
13054                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13055 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13056     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13057     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13058       acquireXlibDisplayEXT( Display &                        dpy,
13059                              VULKAN_HPP_NAMESPACE::DisplayKHR display,
13060                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13061 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13062 
13063     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13064     VULKAN_HPP_NODISCARD Result
13065       getRandROutputDisplayEXT( Display *                          dpy,
13066                                 RROutput                           rrOutput,
13067                                 VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
13068                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13069 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13070     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13071     typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
13072       Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13073 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13075     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
13076       getRandROutputDisplayEXTUnique( Display &          dpy,
13077                                       RROutput           rrOutput,
13078                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13079 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13080 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13081 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
13082 
13083     //=== VK_EXT_display_surface_counter ===
13084 
13085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13086     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(
13087       VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
13088       VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
13089       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13090 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13091     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13092     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
13093       typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
13094       getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
13095                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13096 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13097 
13098     //=== VK_KHR_external_fence_capabilities ===
13099 
13100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13101     void getExternalFencePropertiesKHR(
13102       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
13103       VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
13104       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13107     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
13108       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
13109       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13110 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13111 
13112     //=== VK_KHR_performance_query ===
13113 
13114     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13115     VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(
13116       uint32_t                                                 queueFamilyIndex,
13117       uint32_t *                                               pCounterCount,
13118       VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
13119       VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
13120       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13122     template <typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>,
13123               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13124     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
13125       enumerateQueueFamilyPerformanceQueryCountersKHR(
13126         uint32_t                                                        queueFamilyIndex,
13127         ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
13128         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13129     template <typename Allocator                 = std::allocator<PerformanceCounterDescriptionKHR>,
13130               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13131               typename B                         = Allocator,
13132               typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value,
13133                                       int>::type = 0>
13134     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
13135       enumerateQueueFamilyPerformanceQueryCountersKHR(
13136         uint32_t                                                        queueFamilyIndex,
13137         ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
13138         Allocator const &                                               vectorAllocator,
13139         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13140     template <typename PerformanceCounterKHRAllocator            = std::allocator<PerformanceCounterKHR>,
13141               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
13142               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13143     VULKAN_HPP_NODISCARD typename ResultValueType<
13144       std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
13145                 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
13146       enumerateQueueFamilyPerformanceQueryCountersKHR(
13147         uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13148     template <typename PerformanceCounterKHRAllocator            = std::allocator<PerformanceCounterKHR>,
13149               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
13150               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13151               typename B1                                        = PerformanceCounterKHRAllocator,
13152               typename B2                                        = PerformanceCounterDescriptionKHRAllocator,
13153               typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
13154                                         std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
13155                                       int>::type                 = 0>
13156     VULKAN_HPP_NODISCARD typename ResultValueType<
13157       std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
13158                 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
13159       enumerateQueueFamilyPerformanceQueryCountersKHR(
13160         uint32_t                                    queueFamilyIndex,
13161         PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
13162         PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
13163         Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13164 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13165 
13166     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13167     void getQueueFamilyPerformanceQueryPassesKHR(
13168       const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
13169       uint32_t *                                                      pNumPasses,
13170       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13171 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13173     VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
13174       const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
13175       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13176 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13177 
13178     //=== VK_KHR_get_surface_capabilities2 ===
13179 
13180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13181     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(
13182       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13183       VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
13184       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13185 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13187     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
13188       typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
13189       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13190                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13191     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13192     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
13193       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13194                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13195 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13196 
13197     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13198     VULKAN_HPP_NODISCARD Result
13199       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13200                              uint32_t *                                                  pSurfaceFormatCount,
13201                              VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
13202                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13204     template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
13205               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13206     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
13207       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13208                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13209     template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
13210               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13211               typename B                          = SurfaceFormat2KHRAllocator,
13212               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
13213     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
13214       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13215                              SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
13216                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13217 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13218 
13219     //=== VK_KHR_get_display_properties2 ===
13220 
13221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13222     VULKAN_HPP_NODISCARD Result
13223       getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
13224                                 VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
13225                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13226 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13227     template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
13228               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13229     VULKAN_HPP_NODISCARD
13230       typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
13231       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13232     template <
13233       typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
13234       typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13235       typename B                              = DisplayProperties2KHRAllocator,
13236       typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
13237     VULKAN_HPP_NODISCARD
13238       typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
13239       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
13240                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13241 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13242 
13243     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13244     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(
13245       uint32_t *                                         pPropertyCount,
13246       VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
13247       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13248 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13249     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
13250               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13251     VULKAN_HPP_NODISCARD
13252       typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
13253       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13254     template <
13255       typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
13256       typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13257       typename B                                   = DisplayPlaneProperties2KHRAllocator,
13258       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
13259     VULKAN_HPP_NODISCARD
13260       typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
13261       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
13262                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13264 
13265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13266     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(
13267       VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
13268       uint32_t *                                        pPropertyCount,
13269       VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
13270       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13272     template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
13273               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13274     VULKAN_HPP_NODISCARD
13275       typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
13276       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13277                                     Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13278     template <
13279       typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
13280       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13281       typename B                                  = DisplayModeProperties2KHRAllocator,
13282       typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
13283     VULKAN_HPP_NODISCARD
13284       typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
13285       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
13286                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
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 getDisplayPlaneCapabilities2KHR(
13292       const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
13293       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
13294       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13297     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
13298       typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
13299       getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,
13300                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13301 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13302 
13303     //=== VK_EXT_sample_locations ===
13304 
13305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13306     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
13307                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
13308                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13309       VULKAN_HPP_NOEXCEPT;
13310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13312     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(
13313       VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
13314       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13315 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13316 
13317     //=== VK_EXT_calibrated_timestamps ===
13318 
13319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13320     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(
13321       uint32_t *                            pTimeDomainCount,
13322       VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
13323       Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13325     template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
13326               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13327     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
13328       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13329     template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
13330               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13331               typename B                      = TimeDomainEXTAllocator,
13332               typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type = 0>
13333     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
13334       getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator,
13335                                       Dispatch const & d       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13336 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13337 
13338     //=== VK_KHR_fragment_shading_rate ===
13339 
13340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13341     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(
13342       uint32_t *                                                   pFragmentShadingRateCount,
13343       VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
13344       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13346     template <
13347       typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
13348       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13349     VULKAN_HPP_NODISCARD typename ResultValueType<
13350       std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
13351       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13352     template <
13353       typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
13354       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13355       typename B                                             = PhysicalDeviceFragmentShadingRateKHRAllocator,
13356       typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
13357                               int>::type                     = 0>
13358     VULKAN_HPP_NODISCARD typename ResultValueType<
13359       std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
13360       getFragmentShadingRatesKHR(
13361         PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
13362         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13363 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13364 
13365     //=== VK_EXT_tooling_info ===
13366 
13367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13368     VULKAN_HPP_NODISCARD Result
13369       getToolPropertiesEXT( uint32_t *                                              pToolCount,
13370                             VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
13371                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13373     template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
13374               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13375     VULKAN_HPP_NODISCARD typename ResultValueType<
13376       std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
13377       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13378     template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
13379               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13380               typename B                                        = PhysicalDeviceToolPropertiesEXTAllocator,
13381               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
13382                                       int>::type                = 0>
13383     VULKAN_HPP_NODISCARD typename ResultValueType<
13384       std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
13385       getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator,
13386                             Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13387 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13388 
13389     //=== VK_NV_cooperative_matrix ===
13390 
13391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13392     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(
13393       uint32_t *                                            pPropertyCount,
13394       VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
13395       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13396 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13397     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
13398               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13399     VULKAN_HPP_NODISCARD
13400       typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
13401       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13402     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
13403               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13404               typename B                                      = CooperativeMatrixPropertiesNVAllocator,
13405               typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
13406                                       int>::type              = 0>
13407     VULKAN_HPP_NODISCARD
13408       typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
13409       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
13410                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13411 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13412 
13413     //=== VK_NV_coverage_reduction_mode ===
13414 
13415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13416     VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(
13417       uint32_t *                                                   pCombinationCount,
13418       VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
13419       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13421     template <
13422       typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
13423       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13424     VULKAN_HPP_NODISCARD typename ResultValueType<
13425       std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
13426       getSupportedFramebufferMixedSamplesCombinationsNV(
13427         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13428     template <
13429       typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
13430       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13431       typename B                                             = FramebufferMixedSamplesCombinationNVAllocator,
13432       typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
13433                               int>::type                     = 0>
13434     VULKAN_HPP_NODISCARD typename ResultValueType<
13435       std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
13436       getSupportedFramebufferMixedSamplesCombinationsNV(
13437         FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
13438         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13439 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13440 
13441 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13442     //=== VK_EXT_full_screen_exclusive ===
13443 
13444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13445     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT(
13446       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13447       uint32_t *                                                  pPresentModeCount,
13448       VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
13449       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13450 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13451     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
13452               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13453     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
13454       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13455                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13456     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
13457               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13458               typename B                       = PresentModeKHRAllocator,
13459               typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
13460     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
13461       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13462                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,
13463                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13464 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13465 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
13466 
13467     //=== VK_EXT_acquire_drm_display ===
13468 
13469 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13471     VULKAN_HPP_NODISCARD Result
13472       acquireDrmDisplayEXT( int32_t                          drmFd,
13473                             VULKAN_HPP_NAMESPACE::DisplayKHR display,
13474                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13475 #else
13476     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13477     typename ResultValueType<void>::type
13478          acquireDrmDisplayEXT( int32_t                          drmFd,
13479                                VULKAN_HPP_NAMESPACE::DisplayKHR display,
13480                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13481 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13482 
13483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13484     VULKAN_HPP_NODISCARD Result
13485       getDrmDisplayEXT( int32_t                            drmFd,
13486                         uint32_t                           connectorId,
13487                         VULKAN_HPP_NAMESPACE::DisplayKHR * display,
13488                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13491     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
13492       getDrmDisplayEXT( int32_t            drmFd,
13493                         uint32_t           connectorId,
13494                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13495 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13497     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13498       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
13499       getDrmDisplayEXTUnique( int32_t            drmFd,
13500                               uint32_t           connectorId,
13501                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13502 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13503 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13504 
13505 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13506     //=== VK_NV_acquire_winrt_display ===
13507 
13508 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13510     VULKAN_HPP_NODISCARD Result
13511       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13512                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13513 #  else
13514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13515     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13516       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13517                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13518 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13519 
13520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13521     VULKAN_HPP_NODISCARD Result
13522       getWinrtDisplayNV( uint32_t                           deviceRelativeId,
13523                          VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
13524                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13525 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13527     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
13528       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13529 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13531     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13532       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
13533       getWinrtDisplayNVUnique( uint32_t           deviceRelativeId,
13534                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13535 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13536 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13537 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
13538 
13539 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
13540     //=== VK_EXT_directfb_surface ===
13541 
13542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13543     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
13544                                               IDirectFB *        dfb,
13545                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13546       VULKAN_HPP_NOEXCEPT;
13547 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13549     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
13550                                               IDirectFB &        dfb,
13551                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13552       VULKAN_HPP_NOEXCEPT;
13553 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13554 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
13555 
13556 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
13557     //=== VK_QNX_screen_surface ===
13558 
13559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13560     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
13561                                             struct _screen_window * window,
13562                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13563       VULKAN_HPP_NOEXCEPT;
13564 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13566     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
13567                                             struct _screen_window & window,
13568                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13569       VULKAN_HPP_NOEXCEPT;
13570 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13571 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
13572 
operator VkPhysicalDevice() const13573     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
13574     {
13575       return m_physicalDevice;
13576     }
13577 
operator bool() const13578     explicit operator bool() const VULKAN_HPP_NOEXCEPT
13579     {
13580       return m_physicalDevice != VK_NULL_HANDLE;
13581     }
13582 
operator !() const13583     bool operator!() const VULKAN_HPP_NOEXCEPT
13584     {
13585       return m_physicalDevice == VK_NULL_HANDLE;
13586     }
13587 
13588   private:
13589     VkPhysicalDevice m_physicalDevice = {};
13590   };
13591   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ),
13592                             "handle and wrapper have different size!" );
13593   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevice>::value,
13594                             "PhysicalDevice is not nothrow_move_constructible!" );
13595 
13596   template <>
13597   struct VULKAN_HPP_DEPRECATED(
13598     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePhysicalDevice>
13599   {
13600     using type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
13601   };
13602 
13603   template <>
13604   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
13605   {
13606     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
13607   };
13608 
13609   template <>
13610   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
13611                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
13612   {
13613     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
13614   };
13615 
13616   template <>
13617   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
13618   {
13619     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
13620   };
13621 
13622 #ifndef VULKAN_HPP_NO_SMART_HANDLE
13623   class Instance;
13624   template <typename Dispatch>
13625   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
13626   {
13627   public:
13628     using deleter = ObjectDestroy<Instance, Dispatch>;
13629   };
13630   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13631   template <typename Dispatch>
13632   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
13633   {
13634   public:
13635     using deleter = ObjectDestroy<Instance, Dispatch>;
13636   };
13637   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13638   template <typename Dispatch>
13639   class UniqueHandleTraits<SurfaceKHR, Dispatch>
13640   {
13641   public:
13642     using deleter = ObjectDestroy<Instance, Dispatch>;
13643   };
13644   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13645 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13646 
13647   class Instance
13648   {
13649   public:
13650     using CType      = VkInstance;
13651     using NativeType = VkInstance;
13652 
13653     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
13654       VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
13655     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
13656       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
13657 
13658   public:
13659     VULKAN_HPP_CONSTEXPR         Instance() = default;
Instance(std::nullptr_t)13660     VULKAN_HPP_CONSTEXPR         Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Instance(VkInstance instance)13661     VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
13662 
13663 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkInstance instance)13664     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
13665     {
13666       m_instance = instance;
13667       return *this;
13668     }
13669 #endif
13670 
operator =(std::nullptr_t)13671     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
13672     {
13673       m_instance = {};
13674       return *this;
13675     }
13676 
13677 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
13678     auto operator<=>( Instance const & ) const = default;
13679 #else
operator ==(Instance const & rhs) const13680     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13681     {
13682       return m_instance == rhs.m_instance;
13683     }
13684 
operator !=(Instance const & rhs) const13685     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13686     {
13687       return m_instance != rhs.m_instance;
13688     }
13689 
operator <(Instance const & rhs) const13690     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13691     {
13692       return m_instance < rhs.m_instance;
13693     }
13694 #endif
13695 
13696     //=== VK_VERSION_1_0 ===
13697 
13698     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13699     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13700                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13703     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13704                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13705                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13706 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13707 
13708     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13709     VULKAN_HPP_NODISCARD Result
13710       enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
13711                                 VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
13712                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13714     template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
13715               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13716     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
13717       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13718     template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
13719               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13720               typename B                       = PhysicalDeviceAllocator,
13721               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type = 0>
13722     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
13723       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator,
13724                                 Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13725 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13726 
13727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13728     PFN_vkVoidFunction
13729       getProcAddr( const char *       pName,
13730                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13733     PFN_vkVoidFunction
13734       getProcAddr( const std::string & name,
13735                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13736 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13737 
13738     //=== VK_VERSION_1_1 ===
13739 
13740     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13741     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(
13742       uint32_t *                                            pPhysicalDeviceGroupCount,
13743       VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
13744       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13745 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13746     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
13747               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13748     VULKAN_HPP_NODISCARD
13749       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13750       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13751     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
13752               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13753               typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
13754               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
13755                                       int>::type              = 0>
13756     VULKAN_HPP_NODISCARD
13757       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13758       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
13759                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13760 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13761 
13762     //=== VK_KHR_surface ===
13763 
13764     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13765     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
13766                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13767                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13770     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13771                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13772                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13773                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13774 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13775 
13776     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13777     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
13778                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13779                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13780 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13782     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
13783                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13784                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13785                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13786 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13787 
13788     //=== VK_KHR_display ===
13789 
13790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13791     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(
13792       const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
13793       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13794       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13795       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13798     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13799       createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo,
13800                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13801                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13802                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13803 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13805     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13806       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13807       createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo,
13808                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13809                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13810                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13811 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13812 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13813 
13814 #if defined( VK_USE_PLATFORM_XLIB_KHR )
13815     //=== VK_KHR_xlib_surface ===
13816 
13817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13818     VULKAN_HPP_NODISCARD Result
13819       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
13820                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
13821                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
13822                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13823 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13825     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13826       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
13827                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13828                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13829                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13830 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13832     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13833       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13834       createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
13835                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13836                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13837                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13838 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13839 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13840 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/
13841 
13842 #if defined( VK_USE_PLATFORM_XCB_KHR )
13843     //=== VK_KHR_xcb_surface ===
13844 
13845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13846     VULKAN_HPP_NODISCARD Result
13847       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
13848                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
13849                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
13850                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13851 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13852     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13853     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13854       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
13855                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13856                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13857                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13858 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13860     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13861       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13862       createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
13863                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13864                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13865                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13866 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13867 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13868 #endif     /*VK_USE_PLATFORM_XCB_KHR*/
13869 
13870 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13871     //=== VK_KHR_wayland_surface ===
13872 
13873     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13874     VULKAN_HPP_NODISCARD Result
13875       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
13876                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13877                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13878                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13879 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13880     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13881     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13882       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
13883                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13884                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13885                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13886 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13888     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13889       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13890       createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
13891                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13892                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13893                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13894 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13895 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13896 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
13897 
13898 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
13899     //=== VK_KHR_android_surface ===
13900 
13901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13902     VULKAN_HPP_NODISCARD Result
13903       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
13904                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13905                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13906                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13907 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13909     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13910       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
13911                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13912                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13913                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13914 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13916     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13917       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13918       createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
13919                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13920                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
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 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
13925 
13926 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13927     //=== VK_KHR_win32_surface ===
13928 
13929     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13930     VULKAN_HPP_NODISCARD Result
13931       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
13932                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
13933                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
13934                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13935 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13937     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13938       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
13939                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13940                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13941                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13942 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13943     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13944     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13945       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13946       createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
13947                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13948                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13949                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13950 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13951 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13952 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
13953 
13954     //=== VK_EXT_debug_report ===
13955 
13956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13957     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
13958       const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
13959       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
13960       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
13961       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13964     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
13965       createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo,
13966                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13967                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13968                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13969 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13970     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13971     VULKAN_HPP_INLINE
13972       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
13973       createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo,
13974                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13975                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13976                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13977 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13978 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13979 
13980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13981     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
13982                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13983                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13984       VULKAN_HPP_NOEXCEPT;
13985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13986     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13987     void destroyDebugReportCallbackEXT(
13988       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13989       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13990                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13991       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13992 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13993 
13994     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13995     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
13996                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13997                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13998 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14000     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
14001                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14002                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14003                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14004 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14005 
14006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14007     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
14008                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
14009                                 uint64_t                                       object,
14010                                 size_t                                         location,
14011                                 int32_t                                        messageCode,
14012                                 const char *                                   pLayerPrefix,
14013                                 const char *                                   pMessage,
14014                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14017     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
14018                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
14019                                 uint64_t                                       object,
14020                                 size_t                                         location,
14021                                 int32_t                                        messageCode,
14022                                 const std::string &                            layerPrefix,
14023                                 const std::string &                            message,
14024                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14025 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14026 
14027 #if defined( VK_USE_PLATFORM_GGP )
14028     //=== VK_GGP_stream_descriptor_surface ===
14029 
14030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14031     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP(
14032       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
14033       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
14034       VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
14035       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14036 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14038     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14039       createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
14040                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14041                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14042                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14043 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14045     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14046       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14047       createStreamDescriptorSurfaceGGPUnique(
14048         const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
14049         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14050                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14051         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14052 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14053 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14054 #endif     /*VK_USE_PLATFORM_GGP*/
14055 
14056 #if defined( VK_USE_PLATFORM_VI_NN )
14057     //=== VK_NN_vi_surface ===
14058 
14059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14060     VULKAN_HPP_NODISCARD Result
14061       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
14062                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
14063                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
14064                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14065 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14066     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14067     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14068       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
14069                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14070                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14071                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14072 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14074     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14075       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14076       createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
14077                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14078                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14079                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14080 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14081 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14082 #endif     /*VK_USE_PLATFORM_VI_NN*/
14083 
14084     //=== VK_KHR_device_group_creation ===
14085 
14086     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14087     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(
14088       uint32_t *                                            pPhysicalDeviceGroupCount,
14089       VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
14090       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14092     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
14093               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14094     VULKAN_HPP_NODISCARD
14095       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
14096       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14097     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
14098               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14099               typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
14100               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
14101                                       int>::type              = 0>
14102     VULKAN_HPP_NODISCARD
14103       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
14104       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
14105                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14106 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14107 
14108 #if defined( VK_USE_PLATFORM_IOS_MVK )
14109     //=== VK_MVK_ios_surface ===
14110 
14111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14112     VULKAN_HPP_NODISCARD Result
14113       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
14114                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
14115                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
14116                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14117 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14118     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14119     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14120       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
14121                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14122                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14123                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14124 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14125     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14126     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14127       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14128       createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
14129                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14130                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14131                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14132 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14133 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14134 #endif     /*VK_USE_PLATFORM_IOS_MVK*/
14135 
14136 #if defined( VK_USE_PLATFORM_MACOS_MVK )
14137     //=== VK_MVK_macos_surface ===
14138 
14139     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14140     VULKAN_HPP_NODISCARD Result
14141       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
14142                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
14143                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
14144                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14145 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14147     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14148       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
14149                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14150                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14151                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14152 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14153     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14154     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14155       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14156       createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
14157                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14158                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14159                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14160 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14161 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14162 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/
14163 
14164     //=== VK_EXT_debug_utils ===
14165 
14166     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14167     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
14168       const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
14169       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
14170       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
14171       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14173     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14174     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
14175       createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo,
14176                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14177                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14178                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14179 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14181     VULKAN_HPP_INLINE
14182       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
14183       createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo,
14184                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14185                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14186                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14187 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14188 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14189 
14190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14191     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
14192                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14193                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14194       VULKAN_HPP_NOEXCEPT;
14195 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14196     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14197     void destroyDebugUtilsMessengerEXT(
14198       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14199       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14200                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14201       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14202 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14203 
14204     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14205     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
14206                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14207                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14208 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14209     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14210     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
14211                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14212                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14213                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14214 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14215 
14216     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14217     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
14218                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
14219                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
14220                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14221       VULKAN_HPP_NOEXCEPT;
14222 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14223     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14224     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
14225                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
14226                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,
14227                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14228       VULKAN_HPP_NOEXCEPT;
14229 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14230 
14231 #if defined( VK_USE_PLATFORM_FUCHSIA )
14232     //=== VK_FUCHSIA_imagepipe_surface ===
14233 
14234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14235     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA(
14236       const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
14237       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
14238       VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
14239       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14240 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14242     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14243       createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
14244                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14245                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14246                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14247 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14249     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14250       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14251       createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
14252                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14253                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14254                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14255 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14256 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14257 #endif     /*VK_USE_PLATFORM_FUCHSIA*/
14258 
14259 #if defined( VK_USE_PLATFORM_METAL_EXT )
14260     //=== VK_EXT_metal_surface ===
14261 
14262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14263     VULKAN_HPP_NODISCARD Result
14264       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
14265                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
14266                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
14267                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14268 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14270     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14271       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
14272                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14273                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14274                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14275 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14277     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14278       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14279       createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
14280                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14281                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14282                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14283 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14284 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14285 #endif     /*VK_USE_PLATFORM_METAL_EXT*/
14286 
14287     //=== VK_EXT_headless_surface ===
14288 
14289     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14290     VULKAN_HPP_NODISCARD Result
14291       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
14292                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
14293                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
14294                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14297     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14298       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo,
14299                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14300                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14301                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14302 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14304     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14305       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14306       createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo,
14307                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14308                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14309                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14310 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14311 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14312 
14313 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
14314     //=== VK_EXT_directfb_surface ===
14315 
14316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14317     VULKAN_HPP_NODISCARD Result
14318       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
14319                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
14320                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
14321                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14322 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14324     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14325       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
14326                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14327                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14328                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14329 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14331     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14332       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14333       createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
14334                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14335                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14336                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14337 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14338 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14339 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
14340 
14341 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
14342     //=== VK_QNX_screen_surface ===
14343 
14344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14345     VULKAN_HPP_NODISCARD Result
14346       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
14347                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
14348                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14353       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
14354                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14355                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14356                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14357 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14358     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14359     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14360       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14361       createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
14362                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14363                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14364                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14365 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14366 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14367 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
14368 
operator VkInstance() const14369     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const VULKAN_HPP_NOEXCEPT
14370     {
14371       return m_instance;
14372     }
14373 
operator bool() const14374     explicit operator bool() const VULKAN_HPP_NOEXCEPT
14375     {
14376       return m_instance != VK_NULL_HANDLE;
14377     }
14378 
operator !() const14379     bool operator!() const VULKAN_HPP_NOEXCEPT
14380     {
14381       return m_instance == VK_NULL_HANDLE;
14382     }
14383 
14384   private:
14385     VkInstance m_instance = {};
14386   };
14387   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ),
14388                             "handle and wrapper have different size!" );
14389   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Instance>::value,
14390                             "Instance is not nothrow_move_constructible!" );
14391 
14392   template <>
14393   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eInstance>
14394   {
14395     using type = VULKAN_HPP_NAMESPACE::Instance;
14396   };
14397 
14398   template <>
14399   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
14400   {
14401     using Type = VULKAN_HPP_NAMESPACE::Instance;
14402   };
14403 
14404   template <>
14405   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
14406                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
14407   {
14408     using Type = VULKAN_HPP_NAMESPACE::Instance;
14409   };
14410 
14411   template <>
14412   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
14413   {
14414     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
14415   };
14416 
14417   //=== VK_VERSION_1_0 ===
14418 
14419 #ifndef VULKAN_HPP_NO_SMART_HANDLE
14420   template <typename Dispatch>
14421   class UniqueHandleTraits<Instance, Dispatch>
14422   {
14423   public:
14424     using deleter = ObjectDestroy<NoParent, Dispatch>;
14425   };
14426   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
14427 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14428 
14429   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14430   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
14431                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14432                                               VULKAN_HPP_NAMESPACE::Instance *                  pInstance,
14433                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
14434     VULKAN_HPP_NOEXCEPT;
14435 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14436   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14437   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance(
14438     const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
14439     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14440     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14441 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14442   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14443   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14444     typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
14445     createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo,
14446                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14447                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14448                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14449 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14450 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14451 
14452   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14453   VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties(
14454     const char *                                pLayerName,
14455     uint32_t *                                  pPropertyCount,
14456     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
14457     Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
14458 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14459   template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
14460             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14461   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
14462     enumerateInstanceExtensionProperties( Optional<const std::string> layerName
14463                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14464                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14465   template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
14466             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14467             typename B                            = ExtensionPropertiesAllocator,
14468             typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
14469   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
14470     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
14471                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
14472                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14473 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14474 
14475   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14476   VULKAN_HPP_NODISCARD Result
14477     enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
14478                                       VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
14479                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
14480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14481   template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
14482             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14483   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
14484     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14485   template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
14486             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14487             typename B                        = LayerPropertiesAllocator,
14488             typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
14489   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
14490     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
14491                                       Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14492 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14493 
14494   //=== VK_VERSION_1_1 ===
14495 
14496   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14497   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion(
14498     uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
14499 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14500   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14501   typename ResultValueType<uint32_t>::type
14502     enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14503 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14504 
14505 }  // namespace VULKAN_HPP_NAMESPACE
14506 #endif
14507