• 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 #if defined( VK_USE_PLATFORM_OHOS_OPENHARMONY )
418   //=== VK_OpenHarmony_OHOS_surface ===
419   struct OHOSSurfaceCreateInfoOpenHarmony;
420 #endif /*VK_USE_PLATFORM_OHOS_OPENHARMONY*/
421 
422   //=== VK_EXT_debug_report ===
423   struct DebugReportCallbackCreateInfoEXT;
424 
425   //=== VK_AMD_rasterization_order ===
426   struct PipelineRasterizationStateRasterizationOrderAMD;
427 
428   //=== VK_EXT_debug_marker ===
429   struct DebugMarkerObjectNameInfoEXT;
430   struct DebugMarkerObjectTagInfoEXT;
431   struct DebugMarkerMarkerInfoEXT;
432 
433 #if defined( VK_ENABLE_BETA_EXTENSIONS )
434   //=== VK_KHR_video_queue ===
435   struct VideoQueueFamilyProperties2KHR;
436   struct VideoProfileKHR;
437   struct VideoProfilesKHR;
438   struct VideoCapabilitiesKHR;
439   struct PhysicalDeviceVideoFormatInfoKHR;
440   struct VideoFormatPropertiesKHR;
441   struct VideoPictureResourceKHR;
442   struct VideoReferenceSlotKHR;
443   struct VideoGetMemoryPropertiesKHR;
444   struct VideoBindMemoryKHR;
445   struct VideoSessionCreateInfoKHR;
446   struct VideoSessionParametersCreateInfoKHR;
447   struct VideoSessionParametersUpdateInfoKHR;
448   struct VideoBeginCodingInfoKHR;
449   struct VideoEndCodingInfoKHR;
450   struct VideoCodingControlInfoKHR;
451 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
452 
453 #if defined( VK_ENABLE_BETA_EXTENSIONS )
454   //=== VK_KHR_video_decode_queue ===
455   struct VideoDecodeInfoKHR;
456 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
457 
458   //=== VK_NV_dedicated_allocation ===
459   struct DedicatedAllocationImageCreateInfoNV;
460   struct DedicatedAllocationBufferCreateInfoNV;
461   struct DedicatedAllocationMemoryAllocateInfoNV;
462 
463   //=== VK_EXT_transform_feedback ===
464   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
465   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
466   struct PipelineRasterizationStateStreamCreateInfoEXT;
467 
468   //=== VK_NVX_binary_import ===
469   struct CuModuleCreateInfoNVX;
470   struct CuFunctionCreateInfoNVX;
471   struct CuLaunchInfoNVX;
472 
473   //=== VK_NVX_image_view_handle ===
474   struct ImageViewHandleInfoNVX;
475   struct ImageViewAddressPropertiesNVX;
476 
477 #if defined( VK_ENABLE_BETA_EXTENSIONS )
478   //=== VK_EXT_video_encode_h264 ===
479   struct VideoEncodeH264CapabilitiesEXT;
480   struct VideoEncodeH264SessionCreateInfoEXT;
481   struct VideoEncodeH264SessionParametersCreateInfoEXT;
482   struct VideoEncodeH264SessionParametersAddInfoEXT;
483   struct VideoEncodeH264VclFrameInfoEXT;
484   struct VideoEncodeH264EmitPictureParametersEXT;
485   struct VideoEncodeH264DpbSlotInfoEXT;
486   struct VideoEncodeH264NaluSliceEXT;
487   struct VideoEncodeH264ProfileEXT;
488   struct VideoEncodeH264RateControlInfoEXT;
489   struct VideoEncodeH264RateControlLayerInfoEXT;
490   struct VideoEncodeH264QpEXT;
491   struct VideoEncodeH264FrameSizeEXT;
492 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
493 
494 #if defined( VK_ENABLE_BETA_EXTENSIONS )
495   //=== VK_EXT_video_encode_h265 ===
496   struct VideoEncodeH265CapabilitiesEXT;
497   struct VideoEncodeH265SessionCreateInfoEXT;
498   struct VideoEncodeH265SessionParametersCreateInfoEXT;
499   struct VideoEncodeH265SessionParametersAddInfoEXT;
500   struct VideoEncodeH265VclFrameInfoEXT;
501   struct VideoEncodeH265EmitPictureParametersEXT;
502   struct VideoEncodeH265DpbSlotInfoEXT;
503   struct VideoEncodeH265NaluSliceEXT;
504   struct VideoEncodeH265ProfileEXT;
505   struct VideoEncodeH265ReferenceListsEXT;
506   struct VideoEncodeH265RateControlInfoEXT;
507   struct VideoEncodeH265RateControlLayerInfoEXT;
508   struct VideoEncodeH265QpEXT;
509   struct VideoEncodeH265FrameSizeEXT;
510 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
511 
512 #if defined( VK_ENABLE_BETA_EXTENSIONS )
513   //=== VK_EXT_video_decode_h264 ===
514   struct VideoDecodeH264ProfileEXT;
515   struct VideoDecodeH264CapabilitiesEXT;
516   struct VideoDecodeH264SessionCreateInfoEXT;
517   struct VideoDecodeH264SessionParametersCreateInfoEXT;
518   struct VideoDecodeH264SessionParametersAddInfoEXT;
519   struct VideoDecodeH264PictureInfoEXT;
520   struct VideoDecodeH264MvcEXT;
521   struct VideoDecodeH264DpbSlotInfoEXT;
522 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
523 
524   //=== VK_AMD_texture_gather_bias_lod ===
525   struct TextureLODGatherFormatPropertiesAMD;
526 
527   //=== VK_AMD_shader_info ===
528   struct ShaderResourceUsageAMD;
529   struct ShaderStatisticsInfoAMD;
530 
531   //=== VK_KHR_dynamic_rendering ===
532   struct RenderingInfoKHR;
533   struct RenderingAttachmentInfoKHR;
534   struct PipelineRenderingCreateInfoKHR;
535   struct PhysicalDeviceDynamicRenderingFeaturesKHR;
536   struct CommandBufferInheritanceRenderingInfoKHR;
537   struct RenderingFragmentShadingRateAttachmentInfoKHR;
538   struct RenderingFragmentDensityMapAttachmentInfoEXT;
539   struct AttachmentSampleCountInfoAMD;
540   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
541   struct MultiviewPerViewAttributesInfoNVX;
542 
543 #if defined( VK_USE_PLATFORM_GGP )
544   //=== VK_GGP_stream_descriptor_surface ===
545   struct StreamDescriptorSurfaceCreateInfoGGP;
546 #endif /*VK_USE_PLATFORM_GGP*/
547 
548   //=== VK_NV_corner_sampled_image ===
549   struct PhysicalDeviceCornerSampledImageFeaturesNV;
550 
551   //=== VK_NV_external_memory_capabilities ===
552   struct ExternalImageFormatPropertiesNV;
553 
554   //=== VK_NV_external_memory ===
555   struct ExternalMemoryImageCreateInfoNV;
556   struct ExportMemoryAllocateInfoNV;
557 
558 #if defined( VK_USE_PLATFORM_WIN32_KHR )
559   //=== VK_NV_external_memory_win32 ===
560   struct ImportMemoryWin32HandleInfoNV;
561   struct ExportMemoryWin32HandleInfoNV;
562 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
563 
564 #if defined( VK_USE_PLATFORM_WIN32_KHR )
565   //=== VK_NV_win32_keyed_mutex ===
566   struct Win32KeyedMutexAcquireReleaseInfoNV;
567 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
568 
569   //=== VK_EXT_validation_flags ===
570   struct ValidationFlagsEXT;
571 
572 #if defined( VK_USE_PLATFORM_VI_NN )
573   //=== VK_NN_vi_surface ===
574   struct ViSurfaceCreateInfoNN;
575 #endif /*VK_USE_PLATFORM_VI_NN*/
576 
577   //=== VK_EXT_texture_compression_astc_hdr ===
578   struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
579 
580   //=== VK_EXT_astc_decode_mode ===
581   struct ImageViewASTCDecodeModeEXT;
582   struct PhysicalDeviceASTCDecodeFeaturesEXT;
583 
584 #if defined( VK_USE_PLATFORM_WIN32_KHR )
585   //=== VK_KHR_external_memory_win32 ===
586   struct ImportMemoryWin32HandleInfoKHR;
587   struct ExportMemoryWin32HandleInfoKHR;
588   struct MemoryWin32HandlePropertiesKHR;
589   struct MemoryGetWin32HandleInfoKHR;
590 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
591 
592   //=== VK_KHR_external_memory_fd ===
593   struct ImportMemoryFdInfoKHR;
594   struct MemoryFdPropertiesKHR;
595   struct MemoryGetFdInfoKHR;
596 
597 #if defined( VK_USE_PLATFORM_WIN32_KHR )
598   //=== VK_KHR_win32_keyed_mutex ===
599   struct Win32KeyedMutexAcquireReleaseInfoKHR;
600 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
601 
602 #if defined( VK_USE_PLATFORM_WIN32_KHR )
603   //=== VK_KHR_external_semaphore_win32 ===
604   struct ImportSemaphoreWin32HandleInfoKHR;
605   struct ExportSemaphoreWin32HandleInfoKHR;
606   struct D3D12FenceSubmitInfoKHR;
607   struct SemaphoreGetWin32HandleInfoKHR;
608 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
609 
610   //=== VK_KHR_external_semaphore_fd ===
611   struct ImportSemaphoreFdInfoKHR;
612   struct SemaphoreGetFdInfoKHR;
613 
614   //=== VK_KHR_push_descriptor ===
615   struct PhysicalDevicePushDescriptorPropertiesKHR;
616 
617   //=== VK_EXT_conditional_rendering ===
618   struct ConditionalRenderingBeginInfoEXT;
619   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
620   struct CommandBufferInheritanceConditionalRenderingInfoEXT;
621 
622   //=== VK_KHR_incremental_present ===
623   struct PresentRegionsKHR;
624   struct PresentRegionKHR;
625   struct RectLayerKHR;
626 
627   //=== VK_NV_clip_space_w_scaling ===
628   struct ViewportWScalingNV;
629   struct PipelineViewportWScalingStateCreateInfoNV;
630 
631   //=== VK_EXT_display_surface_counter ===
632   struct SurfaceCapabilities2EXT;
633 
634   //=== VK_EXT_display_control ===
635   struct DisplayPowerInfoEXT;
636   struct DeviceEventInfoEXT;
637   struct DisplayEventInfoEXT;
638   struct SwapchainCounterCreateInfoEXT;
639 
640   //=== VK_GOOGLE_display_timing ===
641   struct RefreshCycleDurationGOOGLE;
642   struct PastPresentationTimingGOOGLE;
643   struct PresentTimesInfoGOOGLE;
644   struct PresentTimeGOOGLE;
645 
646   //=== VK_NVX_multiview_per_view_attributes ===
647   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
648 
649   //=== VK_NV_viewport_swizzle ===
650   struct ViewportSwizzleNV;
651   struct PipelineViewportSwizzleStateCreateInfoNV;
652 
653   //=== VK_EXT_discard_rectangles ===
654   struct PhysicalDeviceDiscardRectanglePropertiesEXT;
655   struct PipelineDiscardRectangleStateCreateInfoEXT;
656 
657   //=== VK_EXT_conservative_rasterization ===
658   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
659   struct PipelineRasterizationConservativeStateCreateInfoEXT;
660 
661   //=== VK_EXT_depth_clip_enable ===
662   struct PhysicalDeviceDepthClipEnableFeaturesEXT;
663   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
664 
665   //=== VK_EXT_hdr_metadata ===
666   struct HdrMetadataEXT;
667   struct XYColorEXT;
668 
669   //=== VK_KHR_shared_presentable_image ===
670   struct SharedPresentSurfaceCapabilitiesKHR;
671 
672 #if defined( VK_USE_PLATFORM_WIN32_KHR )
673   //=== VK_KHR_external_fence_win32 ===
674   struct ImportFenceWin32HandleInfoKHR;
675   struct ExportFenceWin32HandleInfoKHR;
676   struct FenceGetWin32HandleInfoKHR;
677 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
678 
679   //=== VK_KHR_external_fence_fd ===
680   struct ImportFenceFdInfoKHR;
681   struct FenceGetFdInfoKHR;
682 
683   //=== VK_KHR_performance_query ===
684   struct PhysicalDevicePerformanceQueryFeaturesKHR;
685   struct PhysicalDevicePerformanceQueryPropertiesKHR;
686   struct PerformanceCounterKHR;
687   struct PerformanceCounterDescriptionKHR;
688   struct QueryPoolPerformanceCreateInfoKHR;
689   union PerformanceCounterResultKHR;
690   struct AcquireProfilingLockInfoKHR;
691   struct PerformanceQuerySubmitInfoKHR;
692 
693   //=== VK_KHR_get_surface_capabilities2 ===
694   struct PhysicalDeviceSurfaceInfo2KHR;
695   struct SurfaceCapabilities2KHR;
696   struct SurfaceFormat2KHR;
697 
698   //=== VK_KHR_get_display_properties2 ===
699   struct DisplayProperties2KHR;
700   struct DisplayPlaneProperties2KHR;
701   struct DisplayModeProperties2KHR;
702   struct DisplayPlaneInfo2KHR;
703   struct DisplayPlaneCapabilities2KHR;
704 
705 #if defined( VK_USE_PLATFORM_IOS_MVK )
706   //=== VK_MVK_ios_surface ===
707   struct IOSSurfaceCreateInfoMVK;
708 #endif /*VK_USE_PLATFORM_IOS_MVK*/
709 
710 #if defined( VK_USE_PLATFORM_MACOS_MVK )
711   //=== VK_MVK_macos_surface ===
712   struct MacOSSurfaceCreateInfoMVK;
713 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
714 
715   //=== VK_EXT_debug_utils ===
716   struct DebugUtilsLabelEXT;
717   struct DebugUtilsMessengerCallbackDataEXT;
718   struct DebugUtilsMessengerCreateInfoEXT;
719   struct DebugUtilsObjectNameInfoEXT;
720   struct DebugUtilsObjectTagInfoEXT;
721 
722 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
723   //=== VK_ANDROID_external_memory_android_hardware_buffer ===
724   struct AndroidHardwareBufferUsageANDROID;
725   struct AndroidHardwareBufferPropertiesANDROID;
726   struct AndroidHardwareBufferFormatPropertiesANDROID;
727   struct ImportAndroidHardwareBufferInfoANDROID;
728   struct MemoryGetAndroidHardwareBufferInfoANDROID;
729   struct ExternalFormatANDROID;
730   struct AndroidHardwareBufferFormatProperties2ANDROID;
731 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
732 
733   //=== VK_EXT_inline_uniform_block ===
734   struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
735   struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
736   struct WriteDescriptorSetInlineUniformBlockEXT;
737   struct DescriptorPoolInlineUniformBlockCreateInfoEXT;
738 
739   //=== VK_EXT_sample_locations ===
740   struct SampleLocationEXT;
741   struct SampleLocationsInfoEXT;
742   struct AttachmentSampleLocationsEXT;
743   struct SubpassSampleLocationsEXT;
744   struct RenderPassSampleLocationsBeginInfoEXT;
745   struct PipelineSampleLocationsStateCreateInfoEXT;
746   struct PhysicalDeviceSampleLocationsPropertiesEXT;
747   struct MultisamplePropertiesEXT;
748 
749   //=== VK_EXT_blend_operation_advanced ===
750   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
751   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
752   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
753 
754   //=== VK_NV_fragment_coverage_to_color ===
755   struct PipelineCoverageToColorStateCreateInfoNV;
756 
757   //=== VK_KHR_acceleration_structure ===
758   union DeviceOrHostAddressKHR;
759   union DeviceOrHostAddressConstKHR;
760   struct AccelerationStructureBuildRangeInfoKHR;
761   struct AabbPositionsKHR;
762   using AabbPositionsNV = AabbPositionsKHR;
763   struct AccelerationStructureGeometryTrianglesDataKHR;
764   struct TransformMatrixKHR;
765   using TransformMatrixNV = TransformMatrixKHR;
766   struct AccelerationStructureBuildGeometryInfoKHR;
767   struct AccelerationStructureGeometryAabbsDataKHR;
768   struct AccelerationStructureInstanceKHR;
769   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
770   struct AccelerationStructureGeometryInstancesDataKHR;
771   union AccelerationStructureGeometryDataKHR;
772   struct AccelerationStructureGeometryKHR;
773   struct AccelerationStructureCreateInfoKHR;
774   struct WriteDescriptorSetAccelerationStructureKHR;
775   struct PhysicalDeviceAccelerationStructureFeaturesKHR;
776   struct PhysicalDeviceAccelerationStructurePropertiesKHR;
777   struct AccelerationStructureDeviceAddressInfoKHR;
778   struct AccelerationStructureVersionInfoKHR;
779   struct CopyAccelerationStructureToMemoryInfoKHR;
780   struct CopyMemoryToAccelerationStructureInfoKHR;
781   struct CopyAccelerationStructureInfoKHR;
782   struct AccelerationStructureBuildSizesInfoKHR;
783 
784   //=== VK_NV_framebuffer_mixed_samples ===
785   struct PipelineCoverageModulationStateCreateInfoNV;
786 
787   //=== VK_NV_shader_sm_builtins ===
788   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
789   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
790 
791   //=== VK_EXT_image_drm_format_modifier ===
792   struct DrmFormatModifierPropertiesListEXT;
793   struct DrmFormatModifierPropertiesEXT;
794   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
795   struct ImageDrmFormatModifierListCreateInfoEXT;
796   struct ImageDrmFormatModifierExplicitCreateInfoEXT;
797   struct ImageDrmFormatModifierPropertiesEXT;
798   struct DrmFormatModifierPropertiesList2EXT;
799   struct DrmFormatModifierProperties2EXT;
800 
801   //=== VK_EXT_validation_cache ===
802   struct ValidationCacheCreateInfoEXT;
803   struct ShaderModuleValidationCacheCreateInfoEXT;
804 
805 #if defined( VK_ENABLE_BETA_EXTENSIONS )
806   //=== VK_KHR_portability_subset ===
807   struct PhysicalDevicePortabilitySubsetFeaturesKHR;
808   struct PhysicalDevicePortabilitySubsetPropertiesKHR;
809 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
810 
811   //=== VK_NV_shading_rate_image ===
812   struct ShadingRatePaletteNV;
813   struct PipelineViewportShadingRateImageStateCreateInfoNV;
814   struct PhysicalDeviceShadingRateImageFeaturesNV;
815   struct PhysicalDeviceShadingRateImagePropertiesNV;
816   struct CoarseSampleLocationNV;
817   struct CoarseSampleOrderCustomNV;
818   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
819 
820   //=== VK_NV_ray_tracing ===
821   struct RayTracingShaderGroupCreateInfoNV;
822   struct RayTracingPipelineCreateInfoNV;
823   struct GeometryTrianglesNV;
824   struct GeometryAABBNV;
825   struct GeometryDataNV;
826   struct GeometryNV;
827   struct AccelerationStructureInfoNV;
828   struct AccelerationStructureCreateInfoNV;
829   struct BindAccelerationStructureMemoryInfoNV;
830   struct WriteDescriptorSetAccelerationStructureNV;
831   struct AccelerationStructureMemoryRequirementsInfoNV;
832   struct PhysicalDeviceRayTracingPropertiesNV;
833 
834   //=== VK_NV_representative_fragment_test ===
835   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
836   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
837 
838   //=== VK_EXT_filter_cubic ===
839   struct PhysicalDeviceImageViewImageFormatInfoEXT;
840   struct FilterCubicImageViewImageFormatPropertiesEXT;
841 
842   //=== VK_EXT_global_priority ===
843   struct DeviceQueueGlobalPriorityCreateInfoEXT;
844 
845   //=== VK_EXT_external_memory_host ===
846   struct ImportMemoryHostPointerInfoEXT;
847   struct MemoryHostPointerPropertiesEXT;
848   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
849 
850   //=== VK_KHR_shader_clock ===
851   struct PhysicalDeviceShaderClockFeaturesKHR;
852 
853   //=== VK_AMD_pipeline_compiler_control ===
854   struct PipelineCompilerControlCreateInfoAMD;
855 
856   //=== VK_EXT_calibrated_timestamps ===
857   struct CalibratedTimestampInfoEXT;
858 
859   //=== VK_AMD_shader_core_properties ===
860   struct PhysicalDeviceShaderCorePropertiesAMD;
861 
862 #if defined( VK_ENABLE_BETA_EXTENSIONS )
863   //=== VK_EXT_video_decode_h265 ===
864   struct VideoDecodeH265ProfileEXT;
865   struct VideoDecodeH265CapabilitiesEXT;
866   struct VideoDecodeH265SessionCreateInfoEXT;
867   struct VideoDecodeH265SessionParametersCreateInfoEXT;
868   struct VideoDecodeH265SessionParametersAddInfoEXT;
869   struct VideoDecodeH265PictureInfoEXT;
870   struct VideoDecodeH265DpbSlotInfoEXT;
871 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
872 
873   //=== VK_AMD_memory_overallocation_behavior ===
874   struct DeviceMemoryOverallocationCreateInfoAMD;
875 
876   //=== VK_EXT_vertex_attribute_divisor ===
877   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
878   struct VertexInputBindingDivisorDescriptionEXT;
879   struct PipelineVertexInputDivisorStateCreateInfoEXT;
880   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
881 
882 #if defined( VK_USE_PLATFORM_GGP )
883   //=== VK_GGP_frame_token ===
884   struct PresentFrameTokenGGP;
885 #endif /*VK_USE_PLATFORM_GGP*/
886 
887   //=== VK_EXT_pipeline_creation_feedback ===
888   struct PipelineCreationFeedbackCreateInfoEXT;
889   struct PipelineCreationFeedbackEXT;
890 
891   //=== VK_NV_compute_shader_derivatives ===
892   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
893 
894   //=== VK_NV_mesh_shader ===
895   struct PhysicalDeviceMeshShaderFeaturesNV;
896   struct PhysicalDeviceMeshShaderPropertiesNV;
897   struct DrawMeshTasksIndirectCommandNV;
898 
899   //=== VK_NV_fragment_shader_barycentric ===
900   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
901 
902   //=== VK_NV_shader_image_footprint ===
903   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
904 
905   //=== VK_NV_scissor_exclusive ===
906   struct PipelineViewportExclusiveScissorStateCreateInfoNV;
907   struct PhysicalDeviceExclusiveScissorFeaturesNV;
908 
909   //=== VK_NV_device_diagnostic_checkpoints ===
910   struct QueueFamilyCheckpointPropertiesNV;
911   struct CheckpointDataNV;
912 
913   //=== VK_INTEL_shader_integer_functions2 ===
914   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
915 
916   //=== VK_INTEL_performance_query ===
917   union PerformanceValueDataINTEL;
918   struct PerformanceValueINTEL;
919   struct InitializePerformanceApiInfoINTEL;
920   struct QueryPoolPerformanceQueryCreateInfoINTEL;
921   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
922   struct PerformanceMarkerInfoINTEL;
923   struct PerformanceStreamMarkerInfoINTEL;
924   struct PerformanceOverrideInfoINTEL;
925   struct PerformanceConfigurationAcquireInfoINTEL;
926 
927   //=== VK_EXT_pci_bus_info ===
928   struct PhysicalDevicePCIBusInfoPropertiesEXT;
929 
930   //=== VK_AMD_display_native_hdr ===
931   struct DisplayNativeHdrSurfaceCapabilitiesAMD;
932   struct SwapchainDisplayNativeHdrCreateInfoAMD;
933 
934 #if defined( VK_USE_PLATFORM_FUCHSIA )
935   //=== VK_FUCHSIA_imagepipe_surface ===
936   struct ImagePipeSurfaceCreateInfoFUCHSIA;
937 #endif /*VK_USE_PLATFORM_FUCHSIA*/
938 
939   //=== VK_KHR_shader_terminate_invocation ===
940   struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
941 
942 #if defined( VK_USE_PLATFORM_METAL_EXT )
943   //=== VK_EXT_metal_surface ===
944   struct MetalSurfaceCreateInfoEXT;
945 #endif /*VK_USE_PLATFORM_METAL_EXT*/
946 
947   //=== VK_EXT_fragment_density_map ===
948   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
949   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
950   struct RenderPassFragmentDensityMapCreateInfoEXT;
951 
952   //=== VK_EXT_subgroup_size_control ===
953   struct PhysicalDeviceSubgroupSizeControlFeaturesEXT;
954   struct PhysicalDeviceSubgroupSizeControlPropertiesEXT;
955   struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
956 
957   //=== VK_KHR_fragment_shading_rate ===
958   struct FragmentShadingRateAttachmentInfoKHR;
959   struct PipelineFragmentShadingRateStateCreateInfoKHR;
960   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
961   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
962   struct PhysicalDeviceFragmentShadingRateKHR;
963 
964   //=== VK_AMD_shader_core_properties2 ===
965   struct PhysicalDeviceShaderCoreProperties2AMD;
966 
967   //=== VK_AMD_device_coherent_memory ===
968   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
969 
970   //=== VK_EXT_shader_image_atomic_int64 ===
971   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
972 
973   //=== VK_EXT_memory_budget ===
974   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
975 
976   //=== VK_EXT_memory_priority ===
977   struct PhysicalDeviceMemoryPriorityFeaturesEXT;
978   struct MemoryPriorityAllocateInfoEXT;
979 
980   //=== VK_KHR_surface_protected_capabilities ===
981   struct SurfaceProtectedCapabilitiesKHR;
982 
983   //=== VK_NV_dedicated_allocation_image_aliasing ===
984   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
985 
986   //=== VK_EXT_buffer_device_address ===
987   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
988   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
989   struct BufferDeviceAddressCreateInfoEXT;
990 
991   //=== VK_EXT_tooling_info ===
992   struct PhysicalDeviceToolPropertiesEXT;
993 
994   //=== VK_EXT_validation_features ===
995   struct ValidationFeaturesEXT;
996 
997   //=== VK_KHR_present_wait ===
998   struct PhysicalDevicePresentWaitFeaturesKHR;
999 
1000   //=== VK_NV_cooperative_matrix ===
1001   struct CooperativeMatrixPropertiesNV;
1002   struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1003   struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1004 
1005   //=== VK_NV_coverage_reduction_mode ===
1006   struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1007   struct PipelineCoverageReductionStateCreateInfoNV;
1008   struct FramebufferMixedSamplesCombinationNV;
1009 
1010   //=== VK_EXT_fragment_shader_interlock ===
1011   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1012 
1013   //=== VK_EXT_ycbcr_image_arrays ===
1014   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1015 
1016   //=== VK_EXT_provoking_vertex ===
1017   struct PhysicalDeviceProvokingVertexFeaturesEXT;
1018   struct PhysicalDeviceProvokingVertexPropertiesEXT;
1019   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1020 
1021 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1022   //=== VK_EXT_full_screen_exclusive ===
1023   struct SurfaceFullScreenExclusiveInfoEXT;
1024   struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1025   struct SurfaceFullScreenExclusiveWin32InfoEXT;
1026 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1027 
1028   //=== VK_EXT_headless_surface ===
1029   struct HeadlessSurfaceCreateInfoEXT;
1030 
1031   //=== VK_EXT_line_rasterization ===
1032   struct PhysicalDeviceLineRasterizationFeaturesEXT;
1033   struct PhysicalDeviceLineRasterizationPropertiesEXT;
1034   struct PipelineRasterizationLineStateCreateInfoEXT;
1035 
1036   //=== VK_EXT_shader_atomic_float ===
1037   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1038 
1039   //=== VK_EXT_index_type_uint8 ===
1040   struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
1041 
1042   //=== VK_EXT_extended_dynamic_state ===
1043   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1044 
1045   //=== VK_KHR_pipeline_executable_properties ===
1046   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1047   struct PipelineInfoKHR;
1048   struct PipelineExecutablePropertiesKHR;
1049   struct PipelineExecutableInfoKHR;
1050   union PipelineExecutableStatisticValueKHR;
1051   struct PipelineExecutableStatisticKHR;
1052   struct PipelineExecutableInternalRepresentationKHR;
1053 
1054   //=== VK_EXT_shader_atomic_float2 ===
1055   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1056 
1057   //=== VK_EXT_shader_demote_to_helper_invocation ===
1058   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
1059 
1060   //=== VK_NV_device_generated_commands ===
1061   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1062   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1063   struct GraphicsShaderGroupCreateInfoNV;
1064   struct GraphicsPipelineShaderGroupsCreateInfoNV;
1065   struct BindShaderGroupIndirectCommandNV;
1066   struct BindIndexBufferIndirectCommandNV;
1067   struct BindVertexBufferIndirectCommandNV;
1068   struct SetStateFlagsIndirectCommandNV;
1069   struct IndirectCommandsStreamNV;
1070   struct IndirectCommandsLayoutTokenNV;
1071   struct IndirectCommandsLayoutCreateInfoNV;
1072   struct GeneratedCommandsInfoNV;
1073   struct GeneratedCommandsMemoryRequirementsInfoNV;
1074 
1075   //=== VK_NV_inherited_viewport_scissor ===
1076   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1077   struct CommandBufferInheritanceViewportScissorInfoNV;
1078 
1079   //=== VK_KHR_shader_integer_dot_product ===
1080   struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
1081   struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
1082 
1083   //=== VK_EXT_texel_buffer_alignment ===
1084   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1085   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
1086 
1087   //=== VK_QCOM_render_pass_transform ===
1088   struct RenderPassTransformBeginInfoQCOM;
1089   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1090 
1091   //=== VK_EXT_device_memory_report ===
1092   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1093   struct DeviceDeviceMemoryReportCreateInfoEXT;
1094   struct DeviceMemoryReportCallbackDataEXT;
1095 
1096   //=== VK_EXT_robustness2 ===
1097   struct PhysicalDeviceRobustness2FeaturesEXT;
1098   struct PhysicalDeviceRobustness2PropertiesEXT;
1099 
1100   //=== VK_EXT_custom_border_color ===
1101   struct SamplerCustomBorderColorCreateInfoEXT;
1102   struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1103   struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1104 
1105   //=== VK_KHR_pipeline_library ===
1106   struct PipelineLibraryCreateInfoKHR;
1107 
1108   //=== VK_KHR_present_id ===
1109   struct PresentIdKHR;
1110   struct PhysicalDevicePresentIdFeaturesKHR;
1111 
1112   //=== VK_EXT_private_data ===
1113   struct PhysicalDevicePrivateDataFeaturesEXT;
1114   struct DevicePrivateDataCreateInfoEXT;
1115   struct PrivateDataSlotCreateInfoEXT;
1116 
1117   //=== VK_EXT_pipeline_creation_cache_control ===
1118   struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
1119 
1120 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1121   //=== VK_KHR_video_encode_queue ===
1122   struct VideoEncodeInfoKHR;
1123   struct VideoEncodeRateControlInfoKHR;
1124   struct VideoEncodeRateControlLayerInfoKHR;
1125 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1126 
1127   //=== VK_NV_device_diagnostics_config ===
1128   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1129   struct DeviceDiagnosticsConfigCreateInfoNV;
1130 
1131   //=== VK_KHR_synchronization2 ===
1132   struct MemoryBarrier2KHR;
1133   struct BufferMemoryBarrier2KHR;
1134   struct ImageMemoryBarrier2KHR;
1135   struct DependencyInfoKHR;
1136   struct SubmitInfo2KHR;
1137   struct SemaphoreSubmitInfoKHR;
1138   struct CommandBufferSubmitInfoKHR;
1139   struct PhysicalDeviceSynchronization2FeaturesKHR;
1140   struct QueueFamilyCheckpointProperties2NV;
1141   struct CheckpointData2NV;
1142 
1143   //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1144   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1145 
1146   //=== VK_KHR_zero_initialize_workgroup_memory ===
1147   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
1148 
1149   //=== VK_NV_fragment_shading_rate_enums ===
1150   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1151   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1152   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1153 
1154   //=== VK_NV_ray_tracing_motion_blur ===
1155   struct AccelerationStructureGeometryMotionTrianglesDataNV;
1156   struct AccelerationStructureMotionInfoNV;
1157   struct AccelerationStructureMotionInstanceNV;
1158   union AccelerationStructureMotionInstanceDataNV;
1159   struct AccelerationStructureMatrixMotionInstanceNV;
1160   struct AccelerationStructureSRTMotionInstanceNV;
1161   struct SRTDataNV;
1162   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1163 
1164   //=== VK_EXT_ycbcr_2plane_444_formats ===
1165   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1166 
1167   //=== VK_EXT_fragment_density_map2 ===
1168   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1169   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1170 
1171   //=== VK_QCOM_rotated_copy_commands ===
1172   struct CopyCommandTransformInfoQCOM;
1173 
1174   //=== VK_EXT_image_robustness ===
1175   struct PhysicalDeviceImageRobustnessFeaturesEXT;
1176 
1177   //=== VK_KHR_workgroup_memory_explicit_layout ===
1178   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1179 
1180   //=== VK_KHR_copy_commands2 ===
1181   struct CopyBufferInfo2KHR;
1182   struct CopyImageInfo2KHR;
1183   struct CopyBufferToImageInfo2KHR;
1184   struct CopyImageToBufferInfo2KHR;
1185   struct BlitImageInfo2KHR;
1186   struct ResolveImageInfo2KHR;
1187   struct BufferCopy2KHR;
1188   struct ImageCopy2KHR;
1189   struct ImageBlit2KHR;
1190   struct BufferImageCopy2KHR;
1191   struct ImageResolve2KHR;
1192 
1193   //=== VK_EXT_4444_formats ===
1194   struct PhysicalDevice4444FormatsFeaturesEXT;
1195 
1196   //=== VK_ARM_rasterization_order_attachment_access ===
1197   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
1198 
1199   //=== VK_EXT_rgba10x6_formats ===
1200   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1201 
1202 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1203   //=== VK_EXT_directfb_surface ===
1204   struct DirectFBSurfaceCreateInfoEXT;
1205 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1206 
1207   //=== VK_KHR_ray_tracing_pipeline ===
1208   struct RayTracingShaderGroupCreateInfoKHR;
1209   struct RayTracingPipelineCreateInfoKHR;
1210   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
1211   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
1212   struct StridedDeviceAddressRegionKHR;
1213   struct TraceRaysIndirectCommandKHR;
1214   struct RayTracingPipelineInterfaceCreateInfoKHR;
1215 
1216   //=== VK_KHR_ray_query ===
1217   struct PhysicalDeviceRayQueryFeaturesKHR;
1218 
1219   //=== VK_VALVE_mutable_descriptor_type ===
1220   struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
1221   struct MutableDescriptorTypeListVALVE;
1222   struct MutableDescriptorTypeCreateInfoVALVE;
1223 
1224   //=== VK_EXT_vertex_input_dynamic_state ===
1225   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1226   struct VertexInputBindingDescription2EXT;
1227   struct VertexInputAttributeDescription2EXT;
1228 
1229   //=== VK_EXT_physical_device_drm ===
1230   struct PhysicalDeviceDrmPropertiesEXT;
1231 
1232   //=== VK_EXT_depth_clip_control ===
1233   struct PhysicalDeviceDepthClipControlFeaturesEXT;
1234   struct PipelineViewportDepthClipControlCreateInfoEXT;
1235 
1236   //=== VK_EXT_primitive_topology_list_restart ===
1237   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1238 
1239   //=== VK_KHR_format_feature_flags2 ===
1240   struct FormatProperties3KHR;
1241 
1242 #if defined( VK_USE_PLATFORM_FUCHSIA )
1243   //=== VK_FUCHSIA_external_memory ===
1244   struct ImportMemoryZirconHandleInfoFUCHSIA;
1245   struct MemoryZirconHandlePropertiesFUCHSIA;
1246   struct MemoryGetZirconHandleInfoFUCHSIA;
1247 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1248 
1249 #if defined( VK_USE_PLATFORM_FUCHSIA )
1250   //=== VK_FUCHSIA_external_semaphore ===
1251   struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1252   struct SemaphoreGetZirconHandleInfoFUCHSIA;
1253 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1254 
1255 #if defined( VK_USE_PLATFORM_FUCHSIA )
1256   //=== VK_FUCHSIA_buffer_collection ===
1257   struct BufferCollectionCreateInfoFUCHSIA;
1258   struct ImportMemoryBufferCollectionFUCHSIA;
1259   struct BufferCollectionImageCreateInfoFUCHSIA;
1260   struct BufferConstraintsInfoFUCHSIA;
1261   struct BufferCollectionBufferCreateInfoFUCHSIA;
1262   struct BufferCollectionPropertiesFUCHSIA;
1263   struct SysmemColorSpaceFUCHSIA;
1264   struct ImageConstraintsInfoFUCHSIA;
1265   struct ImageFormatConstraintsInfoFUCHSIA;
1266   struct BufferCollectionConstraintsInfoFUCHSIA;
1267 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1268 
1269   //=== VK_HUAWEI_subpass_shading ===
1270   struct SubpassShadingPipelineCreateInfoHUAWEI;
1271   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1272   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1273 
1274   //=== VK_HUAWEI_invocation_mask ===
1275   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1276 
1277   //=== VK_NV_external_memory_rdma ===
1278   struct MemoryGetRemoteAddressInfoNV;
1279   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1280 
1281   //=== VK_EXT_extended_dynamic_state2 ===
1282   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1283 
1284 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1285   //=== VK_QNX_screen_surface ===
1286   struct ScreenSurfaceCreateInfoQNX;
1287 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1288 
1289   //=== VK_EXT_color_write_enable ===
1290   struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1291   struct PipelineColorWriteCreateInfoEXT;
1292 
1293   //=== VK_EXT_global_priority_query ===
1294   struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
1295   struct QueueFamilyGlobalPriorityPropertiesEXT;
1296 
1297   //=== VK_EXT_image_view_min_lod ===
1298   struct PhysicalDeviceImageViewMinLodFeaturesEXT;
1299   struct ImageViewMinLodCreateInfoEXT;
1300 
1301   //=== VK_EXT_multi_draw ===
1302   struct PhysicalDeviceMultiDrawFeaturesEXT;
1303   struct PhysicalDeviceMultiDrawPropertiesEXT;
1304   struct MultiDrawInfoEXT;
1305   struct MultiDrawIndexedInfoEXT;
1306 
1307   //=== VK_EXT_border_color_swizzle ===
1308   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1309   struct SamplerBorderColorComponentMappingCreateInfoEXT;
1310 
1311   //=== VK_EXT_pageable_device_local_memory ===
1312   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1313 
1314   //=== VK_KHR_maintenance4 ===
1315   struct PhysicalDeviceMaintenance4FeaturesKHR;
1316   struct PhysicalDeviceMaintenance4PropertiesKHR;
1317   struct DeviceBufferMemoryRequirementsKHR;
1318   struct DeviceImageMemoryRequirementsKHR;
1319 
1320   //===============
1321   //=== HANDLEs ===
1322   //===============
1323 
1324   class SurfaceKHR
1325   {
1326   public:
1327     using CType      = VkSurfaceKHR;
1328     using NativeType = VkSurfaceKHR;
1329 
1330     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1331       VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
1332     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1333       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
1334 
1335   public:
1336     VULKAN_HPP_CONSTEXPR         SurfaceKHR() = default;
SurfaceKHR(std::nullptr_t)1337     VULKAN_HPP_CONSTEXPR         SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
SurfaceKHR(VkSurfaceKHR surfaceKHR)1338     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR )
1339     {}
1340 
1341 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSurfaceKHR surfaceKHR)1342     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
1343     {
1344       m_surfaceKHR = surfaceKHR;
1345       return *this;
1346     }
1347 #endif
1348 
operator =(std::nullptr_t)1349     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1350     {
1351       m_surfaceKHR = {};
1352       return *this;
1353     }
1354 
1355 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1356     auto operator<=>( SurfaceKHR const & ) const = default;
1357 #else
operator ==(SurfaceKHR const & rhs) const1358     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1359     {
1360       return m_surfaceKHR == rhs.m_surfaceKHR;
1361     }
1362 
operator !=(SurfaceKHR const & rhs) const1363     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1364     {
1365       return m_surfaceKHR != rhs.m_surfaceKHR;
1366     }
1367 
operator <(SurfaceKHR const & rhs) const1368     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1369     {
1370       return m_surfaceKHR < rhs.m_surfaceKHR;
1371     }
1372 #endif
1373 
operator VkSurfaceKHR() const1374     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
1375     {
1376       return m_surfaceKHR;
1377     }
1378 
operator bool() const1379     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1380     {
1381       return m_surfaceKHR != VK_NULL_HANDLE;
1382     }
1383 
operator !() const1384     bool operator!() const VULKAN_HPP_NOEXCEPT
1385     {
1386       return m_surfaceKHR == VK_NULL_HANDLE;
1387     }
1388 
1389   private:
1390     VkSurfaceKHR m_surfaceKHR = {};
1391   };
1392   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ),
1393                             "handle and wrapper have different size!" );
1394   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceKHR>::value,
1395                             "SurfaceKHR is not nothrow_move_constructible!" );
1396 
1397   template <>
1398   struct VULKAN_HPP_DEPRECATED(
1399     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSurfaceKHR>
1400   {
1401     using type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1402   };
1403 
1404   template <>
1405   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
1406   {
1407     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1408   };
1409 
1410   template <>
1411   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1412                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
1413   {
1414     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1415   };
1416 
1417   template <>
1418   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
1419   {
1420     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1421   };
1422 
1423   class DebugReportCallbackEXT
1424   {
1425   public:
1426     using CType      = VkDebugReportCallbackEXT;
1427     using NativeType = VkDebugReportCallbackEXT;
1428 
1429     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1430       VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
1431     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1432       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
1433 
1434   public:
1435     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
DebugReportCallbackEXT(std::nullptr_t)1436     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1437     VULKAN_HPP_TYPESAFE_EXPLICIT
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)1438       DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1439       : m_debugReportCallbackEXT( debugReportCallbackEXT )
1440     {}
1441 
1442 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)1443     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1444     {
1445       m_debugReportCallbackEXT = debugReportCallbackEXT;
1446       return *this;
1447     }
1448 #endif
1449 
operator =(std::nullptr_t)1450     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1451     {
1452       m_debugReportCallbackEXT = {};
1453       return *this;
1454     }
1455 
1456 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1457     auto operator<=>( DebugReportCallbackEXT const & ) const = default;
1458 #else
operator ==(DebugReportCallbackEXT const & rhs) const1459     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1460     {
1461       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
1462     }
1463 
operator !=(DebugReportCallbackEXT const & rhs) const1464     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1465     {
1466       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
1467     }
1468 
operator <(DebugReportCallbackEXT const & rhs) const1469     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1470     {
1471       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
1472     }
1473 #endif
1474 
operator VkDebugReportCallbackEXT() const1475     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
1476     {
1477       return m_debugReportCallbackEXT;
1478     }
1479 
operator bool() const1480     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1481     {
1482       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
1483     }
1484 
operator !() const1485     bool operator!() const VULKAN_HPP_NOEXCEPT
1486     {
1487       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
1488     }
1489 
1490   private:
1491     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
1492   };
1493   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) ==
1494                               sizeof( VkDebugReportCallbackEXT ),
1495                             "handle and wrapper have different size!" );
1496   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::value,
1497                             "DebugReportCallbackEXT is not nothrow_move_constructible!" );
1498 
1499   template <>
1500   struct VULKAN_HPP_DEPRECATED(
1501     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugReportCallbackEXT>
1502   {
1503     using type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1504   };
1505 
1506   template <>
1507   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
1508   {
1509     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1510   };
1511 
1512   template <>
1513   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1514                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
1515   {
1516     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1517   };
1518 
1519   template <>
1520   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
1521   {
1522     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1523   };
1524 
1525   class DebugUtilsMessengerEXT
1526   {
1527   public:
1528     using CType      = VkDebugUtilsMessengerEXT;
1529     using NativeType = VkDebugUtilsMessengerEXT;
1530 
1531     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1532       VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
1533     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1534       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
1535 
1536   public:
1537     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
DebugUtilsMessengerEXT(std::nullptr_t)1538     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1539     VULKAN_HPP_TYPESAFE_EXPLICIT
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1540       DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1541       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
1542     {}
1543 
1544 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1545     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1546     {
1547       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
1548       return *this;
1549     }
1550 #endif
1551 
operator =(std::nullptr_t)1552     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1553     {
1554       m_debugUtilsMessengerEXT = {};
1555       return *this;
1556     }
1557 
1558 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1559     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
1560 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const1561     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1562     {
1563       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
1564     }
1565 
operator !=(DebugUtilsMessengerEXT const & rhs) const1566     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1567     {
1568       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
1569     }
1570 
operator <(DebugUtilsMessengerEXT const & rhs) const1571     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1572     {
1573       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
1574     }
1575 #endif
1576 
operator VkDebugUtilsMessengerEXT() const1577     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
1578     {
1579       return m_debugUtilsMessengerEXT;
1580     }
1581 
operator bool() const1582     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1583     {
1584       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
1585     }
1586 
operator !() const1587     bool operator!() const VULKAN_HPP_NOEXCEPT
1588     {
1589       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
1590     }
1591 
1592   private:
1593     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
1594   };
1595   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) ==
1596                               sizeof( VkDebugUtilsMessengerEXT ),
1597                             "handle and wrapper have different size!" );
1598   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::value,
1599                             "DebugUtilsMessengerEXT is not nothrow_move_constructible!" );
1600 
1601   template <>
1602   struct VULKAN_HPP_DEPRECATED(
1603     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugUtilsMessengerEXT>
1604   {
1605     using type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1606   };
1607 
1608   template <>
1609   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
1610   {
1611     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1612   };
1613 
1614   template <>
1615   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
1616   {
1617     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1618   };
1619 
1620   class DisplayKHR
1621   {
1622   public:
1623     using CType      = VkDisplayKHR;
1624     using NativeType = VkDisplayKHR;
1625 
1626     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1627       VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
1628     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1629       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
1630 
1631   public:
1632     VULKAN_HPP_CONSTEXPR         DisplayKHR() = default;
DisplayKHR(std::nullptr_t)1633     VULKAN_HPP_CONSTEXPR         DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DisplayKHR(VkDisplayKHR displayKHR)1634     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR )
1635     {}
1636 
1637 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayKHR displayKHR)1638     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
1639     {
1640       m_displayKHR = displayKHR;
1641       return *this;
1642     }
1643 #endif
1644 
operator =(std::nullptr_t)1645     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1646     {
1647       m_displayKHR = {};
1648       return *this;
1649     }
1650 
1651 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1652     auto operator<=>( DisplayKHR const & ) const = default;
1653 #else
operator ==(DisplayKHR const & rhs) const1654     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1655     {
1656       return m_displayKHR == rhs.m_displayKHR;
1657     }
1658 
operator !=(DisplayKHR const & rhs) const1659     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1660     {
1661       return m_displayKHR != rhs.m_displayKHR;
1662     }
1663 
operator <(DisplayKHR const & rhs) const1664     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1665     {
1666       return m_displayKHR < rhs.m_displayKHR;
1667     }
1668 #endif
1669 
operator VkDisplayKHR() const1670     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
1671     {
1672       return m_displayKHR;
1673     }
1674 
operator bool() const1675     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1676     {
1677       return m_displayKHR != VK_NULL_HANDLE;
1678     }
1679 
operator !() const1680     bool operator!() const VULKAN_HPP_NOEXCEPT
1681     {
1682       return m_displayKHR == VK_NULL_HANDLE;
1683     }
1684 
1685   private:
1686     VkDisplayKHR m_displayKHR = {};
1687   };
1688   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ),
1689                             "handle and wrapper have different size!" );
1690   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayKHR>::value,
1691                             "DisplayKHR is not nothrow_move_constructible!" );
1692 
1693   template <>
1694   struct VULKAN_HPP_DEPRECATED(
1695     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayKHR>
1696   {
1697     using type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1698   };
1699 
1700   template <>
1701   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
1702   {
1703     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1704   };
1705 
1706   template <>
1707   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1708                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
1709   {
1710     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1711   };
1712 
1713   template <>
1714   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
1715   {
1716     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1717   };
1718 
1719   class SwapchainKHR
1720   {
1721   public:
1722     using CType      = VkSwapchainKHR;
1723     using NativeType = VkSwapchainKHR;
1724 
1725     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1726       VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
1727     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1728       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
1729 
1730   public:
1731     VULKAN_HPP_CONSTEXPR         SwapchainKHR() = default;
SwapchainKHR(std::nullptr_t)1732     VULKAN_HPP_CONSTEXPR         SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
SwapchainKHR(VkSwapchainKHR swapchainKHR)1733     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1734       : m_swapchainKHR( swapchainKHR )
1735     {}
1736 
1737 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSwapchainKHR swapchainKHR)1738     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1739     {
1740       m_swapchainKHR = swapchainKHR;
1741       return *this;
1742     }
1743 #endif
1744 
operator =(std::nullptr_t)1745     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1746     {
1747       m_swapchainKHR = {};
1748       return *this;
1749     }
1750 
1751 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1752     auto operator<=>( SwapchainKHR const & ) const = default;
1753 #else
operator ==(SwapchainKHR const & rhs) const1754     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1755     {
1756       return m_swapchainKHR == rhs.m_swapchainKHR;
1757     }
1758 
operator !=(SwapchainKHR const & rhs) const1759     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1760     {
1761       return m_swapchainKHR != rhs.m_swapchainKHR;
1762     }
1763 
operator <(SwapchainKHR const & rhs) const1764     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1765     {
1766       return m_swapchainKHR < rhs.m_swapchainKHR;
1767     }
1768 #endif
1769 
operator VkSwapchainKHR() const1770     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
1771     {
1772       return m_swapchainKHR;
1773     }
1774 
operator bool() const1775     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1776     {
1777       return m_swapchainKHR != VK_NULL_HANDLE;
1778     }
1779 
operator !() const1780     bool operator!() const VULKAN_HPP_NOEXCEPT
1781     {
1782       return m_swapchainKHR == VK_NULL_HANDLE;
1783     }
1784 
1785   private:
1786     VkSwapchainKHR m_swapchainKHR = {};
1787   };
1788   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ),
1789                             "handle and wrapper have different size!" );
1790   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainKHR>::value,
1791                             "SwapchainKHR is not nothrow_move_constructible!" );
1792 
1793   template <>
1794   struct VULKAN_HPP_DEPRECATED(
1795     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSwapchainKHR>
1796   {
1797     using type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1798   };
1799 
1800   template <>
1801   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
1802   {
1803     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1804   };
1805 
1806   template <>
1807   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1808                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
1809   {
1810     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1811   };
1812 
1813   template <>
1814   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
1815   {
1816     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1817   };
1818 
1819   class Semaphore
1820   {
1821   public:
1822     using CType      = VkSemaphore;
1823     using NativeType = VkSemaphore;
1824 
1825     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1826       VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
1827     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1828       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
1829 
1830   public:
1831     VULKAN_HPP_CONSTEXPR         Semaphore() = default;
Semaphore(std::nullptr_t)1832     VULKAN_HPP_CONSTEXPR         Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Semaphore(VkSemaphore semaphore)1833     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
1834 
1835 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSemaphore semaphore)1836     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
1837     {
1838       m_semaphore = semaphore;
1839       return *this;
1840     }
1841 #endif
1842 
operator =(std::nullptr_t)1843     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1844     {
1845       m_semaphore = {};
1846       return *this;
1847     }
1848 
1849 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1850     auto operator<=>( Semaphore const & ) const = default;
1851 #else
operator ==(Semaphore const & rhs) const1852     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1853     {
1854       return m_semaphore == rhs.m_semaphore;
1855     }
1856 
operator !=(Semaphore const & rhs) const1857     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1858     {
1859       return m_semaphore != rhs.m_semaphore;
1860     }
1861 
operator <(Semaphore const & rhs) const1862     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1863     {
1864       return m_semaphore < rhs.m_semaphore;
1865     }
1866 #endif
1867 
operator VkSemaphore() const1868     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
1869     {
1870       return m_semaphore;
1871     }
1872 
operator bool() const1873     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1874     {
1875       return m_semaphore != VK_NULL_HANDLE;
1876     }
1877 
operator !() const1878     bool operator!() const VULKAN_HPP_NOEXCEPT
1879     {
1880       return m_semaphore == VK_NULL_HANDLE;
1881     }
1882 
1883   private:
1884     VkSemaphore m_semaphore = {};
1885   };
1886   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ),
1887                             "handle and wrapper have different size!" );
1888   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Semaphore>::value,
1889                             "Semaphore is not nothrow_move_constructible!" );
1890 
1891   template <>
1892   struct VULKAN_HPP_DEPRECATED(
1893     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSemaphore>
1894   {
1895     using type = VULKAN_HPP_NAMESPACE::Semaphore;
1896   };
1897 
1898   template <>
1899   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
1900   {
1901     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1902   };
1903 
1904   template <>
1905   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1906                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
1907   {
1908     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1909   };
1910 
1911   template <>
1912   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
1913   {
1914     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1915   };
1916 
1917   class Fence
1918   {
1919   public:
1920     using CType      = VkFence;
1921     using NativeType = VkFence;
1922 
1923     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1924       VULKAN_HPP_NAMESPACE::ObjectType::eFence;
1925     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1926       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
1927 
1928   public:
1929     VULKAN_HPP_CONSTEXPR         Fence() = default;
Fence(std::nullptr_t)1930     VULKAN_HPP_CONSTEXPR         Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Fence(VkFence fence)1931     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
1932 
1933 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFence fence)1934     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
1935     {
1936       m_fence = fence;
1937       return *this;
1938     }
1939 #endif
1940 
operator =(std::nullptr_t)1941     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1942     {
1943       m_fence = {};
1944       return *this;
1945     }
1946 
1947 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1948     auto operator<=>( Fence const & ) const = default;
1949 #else
operator ==(Fence const & rhs) const1950     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1951     {
1952       return m_fence == rhs.m_fence;
1953     }
1954 
operator !=(Fence const & rhs) const1955     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1956     {
1957       return m_fence != rhs.m_fence;
1958     }
1959 
operator <(Fence const & rhs) const1960     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1961     {
1962       return m_fence < rhs.m_fence;
1963     }
1964 #endif
1965 
operator VkFence() const1966     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
1967     {
1968       return m_fence;
1969     }
1970 
operator bool() const1971     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1972     {
1973       return m_fence != VK_NULL_HANDLE;
1974     }
1975 
operator !() const1976     bool operator!() const VULKAN_HPP_NOEXCEPT
1977     {
1978       return m_fence == VK_NULL_HANDLE;
1979     }
1980 
1981   private:
1982     VkFence m_fence = {};
1983   };
1984   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ),
1985                             "handle and wrapper have different size!" );
1986   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Fence>::value,
1987                             "Fence is not nothrow_move_constructible!" );
1988 
1989   template <>
1990   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFence>
1991   {
1992     using type = VULKAN_HPP_NAMESPACE::Fence;
1993   };
1994 
1995   template <>
1996   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
1997   {
1998     using Type = VULKAN_HPP_NAMESPACE::Fence;
1999   };
2000 
2001   template <>
2002   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
2003   {
2004     using Type = VULKAN_HPP_NAMESPACE::Fence;
2005   };
2006 
2007   template <>
2008   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
2009   {
2010     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2011   };
2012 
2013   class PerformanceConfigurationINTEL
2014   {
2015   public:
2016     using CType      = VkPerformanceConfigurationINTEL;
2017     using NativeType = VkPerformanceConfigurationINTEL;
2018 
2019     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2020       VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
2021     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2022       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2023 
2024   public:
2025     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
PerformanceConfigurationINTEL(std::nullptr_t)2026     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2027     VULKAN_HPP_TYPESAFE_EXPLICIT
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2028       PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2029       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
2030     {}
2031 
2032 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2033     PerformanceConfigurationINTEL &
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2034       operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2035     {
2036       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2037       return *this;
2038     }
2039 #endif
2040 
operator =(std::nullptr_t)2041     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2042     {
2043       m_performanceConfigurationINTEL = {};
2044       return *this;
2045     }
2046 
2047 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2048     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
2049 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const2050     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2051     {
2052       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
2053     }
2054 
operator !=(PerformanceConfigurationINTEL const & rhs) const2055     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2056     {
2057       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
2058     }
2059 
operator <(PerformanceConfigurationINTEL const & rhs) const2060     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2061     {
2062       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
2063     }
2064 #endif
2065 
operator VkPerformanceConfigurationINTEL() const2066     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
2067     {
2068       return m_performanceConfigurationINTEL;
2069     }
2070 
operator bool() const2071     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2072     {
2073       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
2074     }
2075 
operator !() const2076     bool operator!() const VULKAN_HPP_NOEXCEPT
2077     {
2078       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
2079     }
2080 
2081   private:
2082     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
2083   };
2084   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) ==
2085                               sizeof( VkPerformanceConfigurationINTEL ),
2086                             "handle and wrapper have different size!" );
2087   VULKAN_HPP_STATIC_ASSERT(
2088     std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::value,
2089     "PerformanceConfigurationINTEL is not nothrow_move_constructible!" );
2090 
2091   template <>
2092   struct VULKAN_HPP_DEPRECATED(
2093     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePerformanceConfigurationINTEL>
2094   {
2095     using type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
2096   };
2097 
2098   template <>
2099   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
2100   {
2101     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
2102   };
2103 
2104   template <>
2105   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
2106   {
2107     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2108   };
2109 
2110   class QueryPool
2111   {
2112   public:
2113     using CType      = VkQueryPool;
2114     using NativeType = VkQueryPool;
2115 
2116     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2117       VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
2118     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2119       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
2120 
2121   public:
2122     VULKAN_HPP_CONSTEXPR         QueryPool() = default;
QueryPool(std::nullptr_t)2123     VULKAN_HPP_CONSTEXPR         QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
QueryPool(VkQueryPool queryPool)2124     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
2125 
2126 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueryPool queryPool)2127     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
2128     {
2129       m_queryPool = queryPool;
2130       return *this;
2131     }
2132 #endif
2133 
operator =(std::nullptr_t)2134     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2135     {
2136       m_queryPool = {};
2137       return *this;
2138     }
2139 
2140 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2141     auto operator<=>( QueryPool const & ) const = default;
2142 #else
operator ==(QueryPool const & rhs) const2143     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2144     {
2145       return m_queryPool == rhs.m_queryPool;
2146     }
2147 
operator !=(QueryPool const & rhs) const2148     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2149     {
2150       return m_queryPool != rhs.m_queryPool;
2151     }
2152 
operator <(QueryPool const & rhs) const2153     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2154     {
2155       return m_queryPool < rhs.m_queryPool;
2156     }
2157 #endif
2158 
operator VkQueryPool() const2159     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
2160     {
2161       return m_queryPool;
2162     }
2163 
operator bool() const2164     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2165     {
2166       return m_queryPool != VK_NULL_HANDLE;
2167     }
2168 
operator !() const2169     bool operator!() const VULKAN_HPP_NOEXCEPT
2170     {
2171       return m_queryPool == VK_NULL_HANDLE;
2172     }
2173 
2174   private:
2175     VkQueryPool m_queryPool = {};
2176   };
2177   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ),
2178                             "handle and wrapper have different size!" );
2179   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueryPool>::value,
2180                             "QueryPool is not nothrow_move_constructible!" );
2181 
2182   template <>
2183   struct VULKAN_HPP_DEPRECATED(
2184     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueryPool>
2185   {
2186     using type = VULKAN_HPP_NAMESPACE::QueryPool;
2187   };
2188 
2189   template <>
2190   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
2191   {
2192     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2193   };
2194 
2195   template <>
2196   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2197                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
2198   {
2199     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2200   };
2201 
2202   template <>
2203   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
2204   {
2205     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2206   };
2207 
2208   class Buffer
2209   {
2210   public:
2211     using CType      = VkBuffer;
2212     using NativeType = VkBuffer;
2213 
2214     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2215       VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
2216     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2217       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
2218 
2219   public:
2220     VULKAN_HPP_CONSTEXPR         Buffer() = default;
Buffer(std::nullptr_t)2221     VULKAN_HPP_CONSTEXPR         Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Buffer(VkBuffer buffer)2222     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
2223 
2224 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBuffer buffer)2225     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
2226     {
2227       m_buffer = buffer;
2228       return *this;
2229     }
2230 #endif
2231 
operator =(std::nullptr_t)2232     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2233     {
2234       m_buffer = {};
2235       return *this;
2236     }
2237 
2238 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2239     auto operator<=>( Buffer const & ) const = default;
2240 #else
operator ==(Buffer const & rhs) const2241     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2242     {
2243       return m_buffer == rhs.m_buffer;
2244     }
2245 
operator !=(Buffer const & rhs) const2246     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2247     {
2248       return m_buffer != rhs.m_buffer;
2249     }
2250 
operator <(Buffer const & rhs) const2251     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2252     {
2253       return m_buffer < rhs.m_buffer;
2254     }
2255 #endif
2256 
operator VkBuffer() const2257     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
2258     {
2259       return m_buffer;
2260     }
2261 
operator bool() const2262     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2263     {
2264       return m_buffer != VK_NULL_HANDLE;
2265     }
2266 
operator !() const2267     bool operator!() const VULKAN_HPP_NOEXCEPT
2268     {
2269       return m_buffer == VK_NULL_HANDLE;
2270     }
2271 
2272   private:
2273     VkBuffer m_buffer = {};
2274   };
2275   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ),
2276                             "handle and wrapper have different size!" );
2277   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Buffer>::value,
2278                             "Buffer is not nothrow_move_constructible!" );
2279 
2280   template <>
2281   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBuffer>
2282   {
2283     using type = VULKAN_HPP_NAMESPACE::Buffer;
2284   };
2285 
2286   template <>
2287   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
2288   {
2289     using Type = VULKAN_HPP_NAMESPACE::Buffer;
2290   };
2291 
2292   template <>
2293   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2294                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
2295   {
2296     using Type = VULKAN_HPP_NAMESPACE::Buffer;
2297   };
2298 
2299   template <>
2300   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
2301   {
2302     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2303   };
2304 
2305   class PipelineLayout
2306   {
2307   public:
2308     using CType      = VkPipelineLayout;
2309     using NativeType = VkPipelineLayout;
2310 
2311     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2312       VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
2313     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2314       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
2315 
2316   public:
2317     VULKAN_HPP_CONSTEXPR         PipelineLayout() = default;
PipelineLayout(std::nullptr_t)2318     VULKAN_HPP_CONSTEXPR         PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PipelineLayout(VkPipelineLayout pipelineLayout)2319     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
2320       : m_pipelineLayout( pipelineLayout )
2321     {}
2322 
2323 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineLayout pipelineLayout)2324     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
2325     {
2326       m_pipelineLayout = pipelineLayout;
2327       return *this;
2328     }
2329 #endif
2330 
operator =(std::nullptr_t)2331     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2332     {
2333       m_pipelineLayout = {};
2334       return *this;
2335     }
2336 
2337 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2338     auto operator<=>( PipelineLayout const & ) const = default;
2339 #else
operator ==(PipelineLayout const & rhs) const2340     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2341     {
2342       return m_pipelineLayout == rhs.m_pipelineLayout;
2343     }
2344 
operator !=(PipelineLayout const & rhs) const2345     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2346     {
2347       return m_pipelineLayout != rhs.m_pipelineLayout;
2348     }
2349 
operator <(PipelineLayout const & rhs) const2350     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2351     {
2352       return m_pipelineLayout < rhs.m_pipelineLayout;
2353     }
2354 #endif
2355 
operator VkPipelineLayout() const2356     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
2357     {
2358       return m_pipelineLayout;
2359     }
2360 
operator bool() const2361     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2362     {
2363       return m_pipelineLayout != VK_NULL_HANDLE;
2364     }
2365 
operator !() const2366     bool operator!() const VULKAN_HPP_NOEXCEPT
2367     {
2368       return m_pipelineLayout == VK_NULL_HANDLE;
2369     }
2370 
2371   private:
2372     VkPipelineLayout m_pipelineLayout = {};
2373   };
2374   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ),
2375                             "handle and wrapper have different size!" );
2376   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineLayout>::value,
2377                             "PipelineLayout is not nothrow_move_constructible!" );
2378 
2379   template <>
2380   struct VULKAN_HPP_DEPRECATED(
2381     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineLayout>
2382   {
2383     using type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2384   };
2385 
2386   template <>
2387   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
2388   {
2389     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2390   };
2391 
2392   template <>
2393   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2394                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
2395   {
2396     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2397   };
2398 
2399   template <>
2400   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
2401   {
2402     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2403   };
2404 
2405   class DescriptorSet
2406   {
2407   public:
2408     using CType      = VkDescriptorSet;
2409     using NativeType = VkDescriptorSet;
2410 
2411     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2412       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
2413     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2414       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
2415 
2416   public:
2417     VULKAN_HPP_CONSTEXPR         DescriptorSet() = default;
DescriptorSet(std::nullptr_t)2418     VULKAN_HPP_CONSTEXPR         DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorSet(VkDescriptorSet descriptorSet)2419     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2420       : m_descriptorSet( descriptorSet )
2421     {}
2422 
2423 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSet descriptorSet)2424     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2425     {
2426       m_descriptorSet = descriptorSet;
2427       return *this;
2428     }
2429 #endif
2430 
operator =(std::nullptr_t)2431     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2432     {
2433       m_descriptorSet = {};
2434       return *this;
2435     }
2436 
2437 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2438     auto operator<=>( DescriptorSet const & ) const = default;
2439 #else
operator ==(DescriptorSet const & rhs) const2440     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2441     {
2442       return m_descriptorSet == rhs.m_descriptorSet;
2443     }
2444 
operator !=(DescriptorSet const & rhs) const2445     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2446     {
2447       return m_descriptorSet != rhs.m_descriptorSet;
2448     }
2449 
operator <(DescriptorSet const & rhs) const2450     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2451     {
2452       return m_descriptorSet < rhs.m_descriptorSet;
2453     }
2454 #endif
2455 
operator VkDescriptorSet() const2456     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
2457     {
2458       return m_descriptorSet;
2459     }
2460 
operator bool() const2461     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2462     {
2463       return m_descriptorSet != VK_NULL_HANDLE;
2464     }
2465 
operator !() const2466     bool operator!() const VULKAN_HPP_NOEXCEPT
2467     {
2468       return m_descriptorSet == VK_NULL_HANDLE;
2469     }
2470 
2471   private:
2472     VkDescriptorSet m_descriptorSet = {};
2473   };
2474   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ),
2475                             "handle and wrapper have different size!" );
2476   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSet>::value,
2477                             "DescriptorSet is not nothrow_move_constructible!" );
2478 
2479   template <>
2480   struct VULKAN_HPP_DEPRECATED(
2481     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSet>
2482   {
2483     using type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2484   };
2485 
2486   template <>
2487   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
2488   {
2489     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2490   };
2491 
2492   template <>
2493   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2494                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
2495   {
2496     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2497   };
2498 
2499   template <>
2500   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
2501   {
2502     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2503   };
2504 
2505   class ImageView
2506   {
2507   public:
2508     using CType      = VkImageView;
2509     using NativeType = VkImageView;
2510 
2511     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2512       VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
2513     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2514       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
2515 
2516   public:
2517     VULKAN_HPP_CONSTEXPR         ImageView() = default;
ImageView(std::nullptr_t)2518     VULKAN_HPP_CONSTEXPR         ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ImageView(VkImageView imageView)2519     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
2520 
2521 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImageView imageView)2522     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
2523     {
2524       m_imageView = imageView;
2525       return *this;
2526     }
2527 #endif
2528 
operator =(std::nullptr_t)2529     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2530     {
2531       m_imageView = {};
2532       return *this;
2533     }
2534 
2535 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2536     auto operator<=>( ImageView const & ) const = default;
2537 #else
operator ==(ImageView const & rhs) const2538     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2539     {
2540       return m_imageView == rhs.m_imageView;
2541     }
2542 
operator !=(ImageView const & rhs) const2543     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2544     {
2545       return m_imageView != rhs.m_imageView;
2546     }
2547 
operator <(ImageView const & rhs) const2548     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2549     {
2550       return m_imageView < rhs.m_imageView;
2551     }
2552 #endif
2553 
operator VkImageView() const2554     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
2555     {
2556       return m_imageView;
2557     }
2558 
operator bool() const2559     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2560     {
2561       return m_imageView != VK_NULL_HANDLE;
2562     }
2563 
operator !() const2564     bool operator!() const VULKAN_HPP_NOEXCEPT
2565     {
2566       return m_imageView == VK_NULL_HANDLE;
2567     }
2568 
2569   private:
2570     VkImageView m_imageView = {};
2571   };
2572   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ),
2573                             "handle and wrapper have different size!" );
2574   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageView>::value,
2575                             "ImageView is not nothrow_move_constructible!" );
2576 
2577   template <>
2578   struct VULKAN_HPP_DEPRECATED(
2579     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImageView>
2580   {
2581     using type = VULKAN_HPP_NAMESPACE::ImageView;
2582   };
2583 
2584   template <>
2585   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
2586   {
2587     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2588   };
2589 
2590   template <>
2591   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2592                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
2593   {
2594     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2595   };
2596 
2597   template <>
2598   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
2599   {
2600     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2601   };
2602 
2603   class Pipeline
2604   {
2605   public:
2606     using CType      = VkPipeline;
2607     using NativeType = VkPipeline;
2608 
2609     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2610       VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
2611     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2612       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
2613 
2614   public:
2615     VULKAN_HPP_CONSTEXPR         Pipeline() = default;
Pipeline(std::nullptr_t)2616     VULKAN_HPP_CONSTEXPR         Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Pipeline(VkPipeline pipeline)2617     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
2618 
2619 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipeline pipeline)2620     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
2621     {
2622       m_pipeline = pipeline;
2623       return *this;
2624     }
2625 #endif
2626 
operator =(std::nullptr_t)2627     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2628     {
2629       m_pipeline = {};
2630       return *this;
2631     }
2632 
2633 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2634     auto operator<=>( Pipeline const & ) const = default;
2635 #else
operator ==(Pipeline const & rhs) const2636     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2637     {
2638       return m_pipeline == rhs.m_pipeline;
2639     }
2640 
operator !=(Pipeline const & rhs) const2641     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2642     {
2643       return m_pipeline != rhs.m_pipeline;
2644     }
2645 
operator <(Pipeline const & rhs) const2646     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2647     {
2648       return m_pipeline < rhs.m_pipeline;
2649     }
2650 #endif
2651 
operator VkPipeline() const2652     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
2653     {
2654       return m_pipeline;
2655     }
2656 
operator bool() const2657     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2658     {
2659       return m_pipeline != VK_NULL_HANDLE;
2660     }
2661 
operator !() const2662     bool operator!() const VULKAN_HPP_NOEXCEPT
2663     {
2664       return m_pipeline == VK_NULL_HANDLE;
2665     }
2666 
2667   private:
2668     VkPipeline m_pipeline = {};
2669   };
2670   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ),
2671                             "handle and wrapper have different size!" );
2672   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Pipeline>::value,
2673                             "Pipeline is not nothrow_move_constructible!" );
2674 
2675   template <>
2676   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipeline>
2677   {
2678     using type = VULKAN_HPP_NAMESPACE::Pipeline;
2679   };
2680 
2681   template <>
2682   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
2683   {
2684     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2685   };
2686 
2687   template <>
2688   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2689                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
2690   {
2691     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2692   };
2693 
2694   template <>
2695   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
2696   {
2697     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2698   };
2699 
2700   class Image
2701   {
2702   public:
2703     using CType      = VkImage;
2704     using NativeType = VkImage;
2705 
2706     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2707       VULKAN_HPP_NAMESPACE::ObjectType::eImage;
2708     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2709       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
2710 
2711   public:
2712     VULKAN_HPP_CONSTEXPR         Image() = default;
Image(std::nullptr_t)2713     VULKAN_HPP_CONSTEXPR         Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Image(VkImage image)2714     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
2715 
2716 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImage image)2717     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
2718     {
2719       m_image = image;
2720       return *this;
2721     }
2722 #endif
2723 
operator =(std::nullptr_t)2724     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2725     {
2726       m_image = {};
2727       return *this;
2728     }
2729 
2730 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2731     auto operator<=>( Image const & ) const = default;
2732 #else
operator ==(Image const & rhs) const2733     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2734     {
2735       return m_image == rhs.m_image;
2736     }
2737 
operator !=(Image const & rhs) const2738     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2739     {
2740       return m_image != rhs.m_image;
2741     }
2742 
operator <(Image const & rhs) const2743     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2744     {
2745       return m_image < rhs.m_image;
2746     }
2747 #endif
2748 
operator VkImage() const2749     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
2750     {
2751       return m_image;
2752     }
2753 
operator bool() const2754     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2755     {
2756       return m_image != VK_NULL_HANDLE;
2757     }
2758 
operator !() const2759     bool operator!() const VULKAN_HPP_NOEXCEPT
2760     {
2761       return m_image == VK_NULL_HANDLE;
2762     }
2763 
2764   private:
2765     VkImage m_image = {};
2766   };
2767   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ),
2768                             "handle and wrapper have different size!" );
2769   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Image>::value,
2770                             "Image is not nothrow_move_constructible!" );
2771 
2772   template <>
2773   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImage>
2774   {
2775     using type = VULKAN_HPP_NAMESPACE::Image;
2776   };
2777 
2778   template <>
2779   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
2780   {
2781     using Type = VULKAN_HPP_NAMESPACE::Image;
2782   };
2783 
2784   template <>
2785   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
2786   {
2787     using Type = VULKAN_HPP_NAMESPACE::Image;
2788   };
2789 
2790   template <>
2791   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
2792   {
2793     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2794   };
2795 
2796   class AccelerationStructureNV
2797   {
2798   public:
2799     using CType      = VkAccelerationStructureNV;
2800     using NativeType = VkAccelerationStructureNV;
2801 
2802     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2803       VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
2804     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2805       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
2806 
2807   public:
2808     VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
AccelerationStructureNV(std::nullptr_t)2809     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2810     VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)2811       AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2812       : m_accelerationStructureNV( accelerationStructureNV )
2813     {}
2814 
2815 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkAccelerationStructureNV accelerationStructureNV)2816     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2817     {
2818       m_accelerationStructureNV = accelerationStructureNV;
2819       return *this;
2820     }
2821 #endif
2822 
operator =(std::nullptr_t)2823     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2824     {
2825       m_accelerationStructureNV = {};
2826       return *this;
2827     }
2828 
2829 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2830     auto operator<=>( AccelerationStructureNV const & ) const = default;
2831 #else
operator ==(AccelerationStructureNV const & rhs) const2832     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2833     {
2834       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
2835     }
2836 
operator !=(AccelerationStructureNV const & rhs) const2837     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2838     {
2839       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
2840     }
2841 
operator <(AccelerationStructureNV const & rhs) const2842     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2843     {
2844       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
2845     }
2846 #endif
2847 
operator VkAccelerationStructureNV() const2848     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
2849     {
2850       return m_accelerationStructureNV;
2851     }
2852 
operator bool() const2853     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2854     {
2855       return m_accelerationStructureNV != VK_NULL_HANDLE;
2856     }
2857 
operator !() const2858     bool operator!() const VULKAN_HPP_NOEXCEPT
2859     {
2860       return m_accelerationStructureNV == VK_NULL_HANDLE;
2861     }
2862 
2863   private:
2864     VkAccelerationStructureNV m_accelerationStructureNV = {};
2865   };
2866   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) ==
2867                               sizeof( VkAccelerationStructureNV ),
2868                             "handle and wrapper have different size!" );
2869   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::value,
2870                             "AccelerationStructureNV is not nothrow_move_constructible!" );
2871 
2872   template <>
2873   struct VULKAN_HPP_DEPRECATED(
2874     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureNV>
2875   {
2876     using type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2877   };
2878 
2879   template <>
2880   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
2881   {
2882     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2883   };
2884 
2885   template <>
2886   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2887                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
2888   {
2889     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2890   };
2891 
2892   template <>
2893   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
2894   {
2895     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2896   };
2897 
2898   class DescriptorUpdateTemplate
2899   {
2900   public:
2901     using CType      = VkDescriptorUpdateTemplate;
2902     using NativeType = VkDescriptorUpdateTemplate;
2903 
2904     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2905       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
2906     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2907       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
2908 
2909   public:
2910     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
DescriptorUpdateTemplate(std::nullptr_t)2911     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2912     VULKAN_HPP_TYPESAFE_EXPLICIT
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)2913       DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
2914       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
2915     {}
2916 
2917 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)2918     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
2919     {
2920       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
2921       return *this;
2922     }
2923 #endif
2924 
operator =(std::nullptr_t)2925     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2926     {
2927       m_descriptorUpdateTemplate = {};
2928       return *this;
2929     }
2930 
2931 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2932     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
2933 #else
operator ==(DescriptorUpdateTemplate const & rhs) const2934     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2935     {
2936       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
2937     }
2938 
operator !=(DescriptorUpdateTemplate const & rhs) const2939     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2940     {
2941       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
2942     }
2943 
operator <(DescriptorUpdateTemplate const & rhs) const2944     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2945     {
2946       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
2947     }
2948 #endif
2949 
operator VkDescriptorUpdateTemplate() const2950     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
2951     {
2952       return m_descriptorUpdateTemplate;
2953     }
2954 
operator bool() const2955     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2956     {
2957       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
2958     }
2959 
operator !() const2960     bool operator!() const VULKAN_HPP_NOEXCEPT
2961     {
2962       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
2963     }
2964 
2965   private:
2966     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
2967   };
2968   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) ==
2969                               sizeof( VkDescriptorUpdateTemplate ),
2970                             "handle and wrapper have different size!" );
2971   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::value,
2972                             "DescriptorUpdateTemplate is not nothrow_move_constructible!" );
2973 
2974   template <>
2975   struct VULKAN_HPP_DEPRECATED(
2976     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorUpdateTemplate>
2977   {
2978     using type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2979   };
2980 
2981   template <>
2982   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
2983   {
2984     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2985   };
2986 
2987   template <>
2988   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2989                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
2990   {
2991     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2992   };
2993 
2994   template <>
2995   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
2996   {
2997     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2998   };
2999   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
3000 
3001   class Event
3002   {
3003   public:
3004     using CType      = VkEvent;
3005     using NativeType = VkEvent;
3006 
3007     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
3008       VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
3009     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3010       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
3011 
3012   public:
3013     VULKAN_HPP_CONSTEXPR         Event() = default;
Event(std::nullptr_t)3014     VULKAN_HPP_CONSTEXPR         Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Event(VkEvent event)3015     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
3016 
3017 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkEvent event)3018     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
3019     {
3020       m_event = event;
3021       return *this;
3022     }
3023 #endif
3024 
operator =(std::nullptr_t)3025     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3026     {
3027       m_event = {};
3028       return *this;
3029     }
3030 
3031 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3032     auto operator<=>( Event const & ) const = default;
3033 #else
operator ==(Event const & rhs) const3034     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3035     {
3036       return m_event == rhs.m_event;
3037     }
3038 
operator !=(Event const & rhs) const3039     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3040     {
3041       return m_event != rhs.m_event;
3042     }
3043 
operator <(Event const & rhs) const3044     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3045     {
3046       return m_event < rhs.m_event;
3047     }
3048 #endif
3049 
operator VkEvent() const3050     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
3051     {
3052       return m_event;
3053     }
3054 
operator bool() const3055     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3056     {
3057       return m_event != VK_NULL_HANDLE;
3058     }
3059 
operator !() const3060     bool operator!() const VULKAN_HPP_NOEXCEPT
3061     {
3062       return m_event == VK_NULL_HANDLE;
3063     }
3064 
3065   private:
3066     VkEvent m_event = {};
3067   };
3068   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ),
3069                             "handle and wrapper have different size!" );
3070   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Event>::value,
3071                             "Event is not nothrow_move_constructible!" );
3072 
3073   template <>
3074   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eEvent>
3075   {
3076     using type = VULKAN_HPP_NAMESPACE::Event;
3077   };
3078 
3079   template <>
3080   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
3081   {
3082     using Type = VULKAN_HPP_NAMESPACE::Event;
3083   };
3084 
3085   template <>
3086   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
3087   {
3088     using Type = VULKAN_HPP_NAMESPACE::Event;
3089   };
3090 
3091   template <>
3092   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
3093   {
3094     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3095   };
3096 
3097   class AccelerationStructureKHR
3098   {
3099   public:
3100     using CType      = VkAccelerationStructureKHR;
3101     using NativeType = VkAccelerationStructureKHR;
3102 
3103     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
3104       VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
3105     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3106       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
3107 
3108   public:
3109     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
AccelerationStructureKHR(std::nullptr_t)3110     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
3111     VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)3112       AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3113       : m_accelerationStructureKHR( accelerationStructureKHR )
3114     {}
3115 
3116 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkAccelerationStructureKHR accelerationStructureKHR)3117     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3118     {
3119       m_accelerationStructureKHR = accelerationStructureKHR;
3120       return *this;
3121     }
3122 #endif
3123 
operator =(std::nullptr_t)3124     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3125     {
3126       m_accelerationStructureKHR = {};
3127       return *this;
3128     }
3129 
3130 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3131     auto operator<=>( AccelerationStructureKHR const & ) const = default;
3132 #else
operator ==(AccelerationStructureKHR const & rhs) const3133     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3134     {
3135       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
3136     }
3137 
operator !=(AccelerationStructureKHR const & rhs) const3138     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3139     {
3140       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
3141     }
3142 
operator <(AccelerationStructureKHR const & rhs) const3143     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3144     {
3145       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
3146     }
3147 #endif
3148 
operator VkAccelerationStructureKHR() const3149     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
3150     {
3151       return m_accelerationStructureKHR;
3152     }
3153 
operator bool() const3154     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3155     {
3156       return m_accelerationStructureKHR != VK_NULL_HANDLE;
3157     }
3158 
operator !() const3159     bool operator!() const VULKAN_HPP_NOEXCEPT
3160     {
3161       return m_accelerationStructureKHR == VK_NULL_HANDLE;
3162     }
3163 
3164   private:
3165     VkAccelerationStructureKHR m_accelerationStructureKHR = {};
3166   };
3167   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) ==
3168                               sizeof( VkAccelerationStructureKHR ),
3169                             "handle and wrapper have different size!" );
3170   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::value,
3171                             "AccelerationStructureKHR is not nothrow_move_constructible!" );
3172 
3173   template <>
3174   struct VULKAN_HPP_DEPRECATED(
3175     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureKHR>
3176   {
3177     using type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3178   };
3179 
3180   template <>
3181   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
3182   {
3183     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3184   };
3185 
3186   template <>
3187   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
3188                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
3189   {
3190     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3191   };
3192 
3193   template <>
3194   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
3195   {
3196     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3197   };
3198 
3199   class CommandBuffer
3200   {
3201   public:
3202     using CType      = VkCommandBuffer;
3203     using NativeType = VkCommandBuffer;
3204 
3205     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
3206       VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
3207     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
3208       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
3209 
3210   public:
3211     VULKAN_HPP_CONSTEXPR         CommandBuffer() = default;
CommandBuffer(std::nullptr_t)3212     VULKAN_HPP_CONSTEXPR         CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CommandBuffer(VkCommandBuffer commandBuffer)3213     VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
3214       : m_commandBuffer( commandBuffer )
3215     {}
3216 
3217 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandBuffer commandBuffer)3218     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
3219     {
3220       m_commandBuffer = commandBuffer;
3221       return *this;
3222     }
3223 #endif
3224 
operator =(std::nullptr_t)3225     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3226     {
3227       m_commandBuffer = {};
3228       return *this;
3229     }
3230 
3231 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3232     auto operator<=>( CommandBuffer const & ) const = default;
3233 #else
operator ==(CommandBuffer const & rhs) const3234     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3235     {
3236       return m_commandBuffer == rhs.m_commandBuffer;
3237     }
3238 
operator !=(CommandBuffer const & rhs) const3239     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3240     {
3241       return m_commandBuffer != rhs.m_commandBuffer;
3242     }
3243 
operator <(CommandBuffer const & rhs) const3244     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3245     {
3246       return m_commandBuffer < rhs.m_commandBuffer;
3247     }
3248 #endif
3249 
3250     //=== VK_VERSION_1_0 ===
3251 
3252     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3253     VULKAN_HPP_NODISCARD Result
3254       begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
3255              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3256 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3258     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
3259       begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,
3260              Dispatch const & d                                   VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3261 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3262 
3263 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3264     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3265     VULKAN_HPP_NODISCARD Result
3266       end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3267 #else
3268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3269     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
3270       end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3271 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3272 
3273 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3275     VULKAN_HPP_NODISCARD Result
3276       reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
3277              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3278 #else
3279     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3280     typename ResultValueType<void>::type
3281          reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
3282                 Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3283 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3284 
3285     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3286     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
3287                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
3288                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3289 
3290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3291     void setViewport( uint32_t                               firstViewport,
3292                       uint32_t                               viewportCount,
3293                       const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
3294                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3297     void setViewport( uint32_t                                                 firstViewport,
3298                       ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
3299                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3300 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3301 
3302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3303     void setScissor( uint32_t                             firstScissor,
3304                      uint32_t                             scissorCount,
3305                      const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
3306                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3309     void setScissor( uint32_t                                               firstScissor,
3310                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
3311                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3312 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3313 
3314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3315     void setLineWidth( float              lineWidth,
3316                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3317 
3318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3319     void setDepthBias( float              depthBiasConstantFactor,
3320                        float              depthBiasClamp,
3321                        float              depthBiasSlopeFactor,
3322                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3323 
3324     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3325     void setBlendConstants( const float        blendConstants[4],
3326                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3327 
3328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3329     void setDepthBounds( float              minDepthBounds,
3330                          float              maxDepthBounds,
3331                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3332 
3333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3334     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
3335                                 uint32_t                               compareMask,
3336                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3337 
3338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3339     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
3340                               uint32_t                               writeMask,
3341                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3342 
3343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3344     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
3345                               uint32_t                               reference,
3346                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3347 
3348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3349     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
3350                              VULKAN_HPP_NAMESPACE::PipelineLayout        layout,
3351                              uint32_t                                    firstSet,
3352                              uint32_t                                    descriptorSetCount,
3353                              const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
3354                              uint32_t                                    dynamicOffsetCount,
3355                              const uint32_t *                            pDynamicOffsets,
3356                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3358     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3359     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                       pipelineBindPoint,
3360                              VULKAN_HPP_NAMESPACE::PipelineLayout                          layout,
3361                              uint32_t                                                      firstSet,
3362                              ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
3363                              ArrayProxy<const uint32_t> const &                            dynamicOffsets,
3364                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3365 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3366 
3367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3368     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3369                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
3370                           VULKAN_HPP_NAMESPACE::IndexType  indexType,
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 bindVertexBuffers( uint32_t                                 firstBinding,
3375                             uint32_t                                 bindingCount,
3376                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
3377                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
3378                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3379 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3380     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3381     void bindVertexBuffers( uint32_t                                                   firstBinding,
3382                             ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
3383                             ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
3384                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3385       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3386 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3387 
3388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3389     void draw( uint32_t           vertexCount,
3390                uint32_t           instanceCount,
3391                uint32_t           firstVertex,
3392                uint32_t           firstInstance,
3393                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3394 
3395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3396     void drawIndexed( uint32_t           indexCount,
3397                       uint32_t           instanceCount,
3398                       uint32_t           firstIndex,
3399                       int32_t            vertexOffset,
3400                       uint32_t           firstInstance,
3401                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3402 
3403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3404     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3405                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
3406                        uint32_t                         drawCount,
3407                        uint32_t                         stride,
3408                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3409 
3410     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3411     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3412                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
3413                               uint32_t                         drawCount,
3414                               uint32_t                         stride,
3415                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3416 
3417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3418     void dispatch( uint32_t           groupCountX,
3419                    uint32_t           groupCountY,
3420                    uint32_t           groupCountZ,
3421                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3422 
3423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3424     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3425                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
3426                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3427 
3428     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3429     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
3430                      VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
3431                      uint32_t                                 regionCount,
3432                      const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
3433                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3434 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3436     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
3437                      VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
3438                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
3439                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3440 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3441 
3442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3443     void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
3444                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
3445                     VULKAN_HPP_NAMESPACE::Image             dstImage,
3446                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
3447                     uint32_t                                regionCount,
3448                     const VULKAN_HPP_NAMESPACE::ImageCopy * 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 copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
3453                     VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
3454                     VULKAN_HPP_NAMESPACE::Image                               dstImage,
3455                     VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
3456                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
3457                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3458 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3459 
3460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3461     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
3462                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
3463                     VULKAN_HPP_NAMESPACE::Image             dstImage,
3464                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
3465                     uint32_t                                regionCount,
3466                     const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
3467                     VULKAN_HPP_NAMESPACE::Filter            filter,
3468                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3471     void blitImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
3472                     VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
3473                     VULKAN_HPP_NAMESPACE::Image                               dstImage,
3474                     VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
3475                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
3476                     VULKAN_HPP_NAMESPACE::Filter                              filter,
3477                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3478 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3479 
3480     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3481     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
3482                             VULKAN_HPP_NAMESPACE::Image                   dstImage,
3483                             VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
3484                             uint32_t                                      regionCount,
3485                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3486                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3489     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
3490                             VULKAN_HPP_NAMESPACE::Image                                     dstImage,
3491                             VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
3492                             ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
3493                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3494 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3495 
3496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3497     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
3498                             VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
3499                             VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
3500                             uint32_t                                      regionCount,
3501                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
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 copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
3506                             VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
3507                             VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
3508                             ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
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 updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3514                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3515                        VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
3516                        const void *                     pData,
3517                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3518 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3519     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3520     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3521                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3522                        ArrayProxy<const T> const &      data,
3523                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3524 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3525 
3526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3527     void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3528                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3529                      VULKAN_HPP_NAMESPACE::DeviceSize size,
3530                      uint32_t                         data,
3531                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3532 
3533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3534     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
3535                           VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,
3536                           const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,
3537                           uint32_t                                            rangeCount,
3538                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
3539                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3542     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                           image,
3543                           VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
3544                           const VULKAN_HPP_NAMESPACE::ClearColorValue &                         color,
3545                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
3546                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3547 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3548 
3549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3550     void
3551       clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
3552                               VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
3553                               const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
3554                               uint32_t                                             rangeCount,
3555                               const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
3556                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3557 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3559     void
3560       clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                           image,
3561                               VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
3562                               const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue &                  depthStencil,
3563                               ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
3564                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3565 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3566 
3567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3568     void clearAttachments( uint32_t                                      attachmentCount,
3569                            const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
3570                            uint32_t                                      rectCount,
3571                            const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
3572                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3573 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3575     void clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
3576                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
3577                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3578 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3579 
3580     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3581     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
3582                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
3583                        VULKAN_HPP_NAMESPACE::Image                dstImage,
3584                        VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
3585                        uint32_t                                   regionCount,
3586                        const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
3587                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3590     void resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
3591                        VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
3592                        VULKAN_HPP_NAMESPACE::Image                                  dstImage,
3593                        VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
3594                        ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
3595                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3596 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3597 
3598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3599     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
3600                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
3601                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3602 
3603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3604     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
3605                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
3606                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3607 
3608     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3609     void waitEvents( uint32_t                                          eventCount,
3610                      const VULKAN_HPP_NAMESPACE::Event *               pEvents,
3611                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
3612                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
3613                      uint32_t                                          memoryBarrierCount,
3614                      const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
3615                      uint32_t                                          bufferMemoryBarrierCount,
3616                      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3617                      uint32_t                                          imageMemoryBarrierCount,
3618                      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
3619                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3620 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3622     void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
3623                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
3624                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
3625                      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
3626                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
3627                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
3628                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3629 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3630 
3631     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3632     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
3633                           VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
3634                           VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
3635                           uint32_t                                          memoryBarrierCount,
3636                           const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
3637                           uint32_t                                          bufferMemoryBarrierCount,
3638                           const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3639                           uint32_t                                          imageMemoryBarrierCount,
3640                           const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
3641                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3644     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
3645                           VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
3646                           VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
3647                           ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
3648                           ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
3649                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
3650                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3651 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3652 
3653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3654     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
3655                      uint32_t                                query,
3656                      VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
3657                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3658 
3659     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3660     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3661                    uint32_t                        query,
3662                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3663 
3664     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3665     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3666                          uint32_t                        firstQuery,
3667                          uint32_t                        queryCount,
3668                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3669 
3670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3671     void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
3672                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
3673                          uint32_t                                    query,
3674                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3675 
3676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3677     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
3678                                uint32_t                               firstQuery,
3679                                uint32_t                               queryCount,
3680                                VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
3681                                VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
3682                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
3683                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
3684                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3685 
3686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3687     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
3688                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
3689                         uint32_t                               offset,
3690                         uint32_t                               size,
3691                         const void *                           pValues,
3692                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3694     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3695     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
3696                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
3697                         uint32_t                               offset,
3698                         ArrayProxy<const T> const &            values,
3699                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3700 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3701 
3702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3703     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3704                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
3705                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3706 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3708     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
3709                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
3710                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3711 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3712 
3713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3714     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
3715                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3716 
3717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3718     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3719 
3720     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3721     void executeCommands( uint32_t                                    commandBufferCount,
3722                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
3723                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3726     void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
3727                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3728 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3729 
3730     //=== VK_VERSION_1_1 ===
3731 
3732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3733     void setDeviceMask( uint32_t           deviceMask,
3734                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3735 
3736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3737     void dispatchBase( uint32_t           baseGroupX,
3738                        uint32_t           baseGroupY,
3739                        uint32_t           baseGroupZ,
3740                        uint32_t           groupCountX,
3741                        uint32_t           groupCountY,
3742                        uint32_t           groupCountZ,
3743                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3744 
3745     //=== VK_VERSION_1_2 ===
3746 
3747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3748     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3749                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
3750                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3751                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3752                             uint32_t                         maxDrawCount,
3753                             uint32_t                         stride,
3754                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3755 
3756     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3757     void
3758       drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3759                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
3760                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3761                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3762                                 uint32_t                         maxDrawCount,
3763                                 uint32_t                         stride,
3764                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3765 
3766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3767     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3768                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
3769                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3770 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3772     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
3773                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
3774                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3775 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3776 
3777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3778     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
3779                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
3780                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3781 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3782     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3783     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
3784                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
3785                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3786 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3787 
3788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3789     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
3790                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3791 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3793     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
3794                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3795 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3796 
3797     //=== VK_EXT_debug_marker ===
3798 
3799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3800     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
3801                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3802 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3804     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
3805                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3806 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3807 
3808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3809     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3810 
3811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3812     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
3813                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3814 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3815     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3816     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
3817                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3818 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3819 
3820 #if defined( VK_ENABLE_BETA_EXTENSIONS )
3821     //=== VK_KHR_video_queue ===
3822 
3823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3824     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
3825                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3826 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3828     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
3829                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3830 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3831 
3832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3833     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
3834                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3835 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3837     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
3838                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3839 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3840 
3841     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3842     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
3843                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3844 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3846     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
3847                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3848 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3849 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
3850 
3851 #if defined( VK_ENABLE_BETA_EXTENSIONS )
3852     //=== VK_KHR_video_decode_queue ===
3853 
3854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3855     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
3856                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3857 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3859     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & frameInfo,
3860                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3861 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3862 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
3863 
3864     //=== VK_EXT_transform_feedback ===
3865 
3866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3867     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
3868                                           uint32_t                                 bindingCount,
3869                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
3870                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
3871                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
3872                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3873       VULKAN_HPP_NOEXCEPT;
3874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3875     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3876     void bindTransformFeedbackBuffersEXT(
3877       uint32_t                                                         firstBinding,
3878       ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &           buffers,
3879       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &       offsets,
3880       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3881       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3882 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3883 
3884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3885     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
3886                                     uint32_t                                 counterBufferCount,
3887                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
3888                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
3889                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3890       VULKAN_HPP_NOEXCEPT;
3891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3892     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3893     void beginTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
3894                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
3895                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
3896                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3897                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3898       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3899 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3900 
3901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3902     void
3903       endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
3904                                uint32_t                                 counterBufferCount,
3905                                const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
3906                                const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
3907                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3909     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3910     void endTransformFeedbackEXT( uint32_t                                               firstCounterBuffer,
3911                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
3912                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
3913                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3914                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3915       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3916 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3917 
3918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3919     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
3920                                uint32_t                                query,
3921                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
3922                                uint32_t                                index,
3923                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3924 
3925     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3926     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3927                              uint32_t                        query,
3928                              uint32_t                        index,
3929                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3930 
3931     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3932     void
3933       drawIndirectByteCountEXT( uint32_t                         instanceCount,
3934                                 uint32_t                         firstInstance,
3935                                 VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
3936                                 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
3937                                 uint32_t                         counterOffset,
3938                                 uint32_t                         vertexStride,
3939                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3940 
3941     //=== VK_NVX_binary_import ===
3942 
3943     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3944     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
3945                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3948     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,
3949                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3950 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3951 
3952     //=== VK_AMD_draw_indirect_count ===
3953 
3954     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3955     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3956                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
3957                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3958                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3959                                uint32_t                         maxDrawCount,
3960                                uint32_t                         stride,
3961                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3962 
3963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3964     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3965                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
3966                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3967                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3968                                       uint32_t                         maxDrawCount,
3969                                       uint32_t                         stride,
3970                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3971       VULKAN_HPP_NOEXCEPT;
3972 
3973     //=== VK_KHR_dynamic_rendering ===
3974 
3975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3976     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfoKHR * pRenderingInfo,
3977                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3978 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3980     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfoKHR & renderingInfo,
3981                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3982 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3983 
3984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3985     void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3986 
3987     //=== VK_KHR_device_group ===
3988 
3989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3990     void setDeviceMaskKHR( uint32_t           deviceMask,
3991                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3992 
3993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3994     void dispatchBaseKHR( uint32_t           baseGroupX,
3995                           uint32_t           baseGroupY,
3996                           uint32_t           baseGroupZ,
3997                           uint32_t           groupCountX,
3998                           uint32_t           groupCountY,
3999                           uint32_t           groupCountZ,
4000                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4001 
4002     //=== VK_KHR_push_descriptor ===
4003 
4004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4005     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
4006                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
4007                                uint32_t                                         set,
4008                                uint32_t                                         descriptorWriteCount,
4009                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
4010                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4012     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4013     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
4014                                VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
4015                                uint32_t                                                           set,
4016                                ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
4017                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4018 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4019 
4020     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4021     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
4022                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
4023                                            uint32_t                                       set,
4024                                            const void *                                   pData,
4025                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4026       VULKAN_HPP_NOEXCEPT;
4027 
4028     //=== VK_EXT_conditional_rendering ===
4029 
4030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4031     void beginConditionalRenderingEXT(
4032       const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
4033       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4035     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4036     void beginConditionalRenderingEXT(
4037       const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
4038       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4039 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4040 
4041     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4042     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4043       VULKAN_HPP_NOEXCEPT;
4044 
4045     //=== VK_NV_clip_space_w_scaling ===
4046 
4047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4048     void setViewportWScalingNV( uint32_t                                         firstViewport,
4049                                 uint32_t                                         viewportCount,
4050                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
4051                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4052 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4053     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4054     void setViewportWScalingNV( uint32_t                                                           firstViewport,
4055                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
4056                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4057 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4058 
4059     //=== VK_EXT_discard_rectangles ===
4060 
4061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4062     void
4063       setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
4064                               uint32_t                             discardRectangleCount,
4065                               const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
4066                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4069     void
4070       setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
4071                               ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
4072                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4073 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4074 
4075     //=== VK_KHR_create_renderpass2 ===
4076 
4077     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4078     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4079                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
4080                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4082     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4083     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4084                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo &    subpassBeginInfo,
4085                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4086 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4087 
4088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4089     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4090                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
4091                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4092 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4094     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4095                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo &   subpassEndInfo,
4096                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4097 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4098 
4099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4100     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4101                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4103     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4104     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4105                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4106 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4107 
4108     //=== VK_EXT_debug_utils ===
4109 
4110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4111     void
4112       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
4113                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4116     void
4117       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
4118                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4119 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4120 
4121     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4122     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4123 
4124     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4125     void
4126       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
4127                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4130     void
4131       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
4132                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4133 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4134 
4135     //=== VK_EXT_sample_locations ===
4136 
4137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4138     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
4139                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4141     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4142     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
4143                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4144 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4145 
4146     //=== VK_KHR_acceleration_structure ===
4147 
4148     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4149     void buildAccelerationStructuresKHR(
4150       uint32_t                                                                     infoCount,
4151       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
4152       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
4153       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4156     void buildAccelerationStructuresKHR(
4157       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
4158       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
4159       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4160 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4161 
4162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4163     void buildAccelerationStructuresIndirectKHR(
4164       uint32_t                                                                infoCount,
4165       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
4166       const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
4167       const uint32_t *                                                        pIndirectStrides,
4168       const uint32_t * const *                                                ppMaxPrimitiveCounts,
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 buildAccelerationStructuresIndirectKHR(
4173       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
4174       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
4175       ArrayProxy<const uint32_t> const &                                                        indirectStrides,
4176       ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
4177       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4178 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4179 
4180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4181     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
4182                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4183       VULKAN_HPP_NOEXCEPT;
4184 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4185     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4186     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
4187                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4188       VULKAN_HPP_NOEXCEPT;
4189 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4190 
4191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4192     void copyAccelerationStructureToMemoryKHR(
4193       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
4194       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4195 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4196     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4197     void copyAccelerationStructureToMemoryKHR(
4198       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
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 copyMemoryToAccelerationStructureKHR(
4204       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
4205       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4206 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4207     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4208     void copyMemoryToAccelerationStructureKHR(
4209       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
4210       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4211 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4212 
4213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4214     void writeAccelerationStructuresPropertiesKHR(
4215       uint32_t                                               accelerationStructureCount,
4216       const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
4217       VULKAN_HPP_NAMESPACE::QueryType                        queryType,
4218       VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
4219       uint32_t                                               firstQuery,
4220       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4222     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4223     void writeAccelerationStructuresPropertiesKHR(
4224       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
4225       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
4226       VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
4227       uint32_t                                                                 firstQuery,
4228       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4229 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4230 
4231     //=== VK_NV_shading_rate_image ===
4232 
4233     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4234     void
4235       bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
4236                               VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
4237                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4238 
4239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4240     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
4241                                           uint32_t                                           viewportCount,
4242                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
4243                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4244       VULKAN_HPP_NOEXCEPT;
4245 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4247     void setViewportShadingRatePaletteNV(
4248       uint32_t                                                             firstViewport,
4249       ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
4250       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4251 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4252 
4253     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4254     void
4255       setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
4256                               uint32_t                                                customSampleOrderCount,
4257                               const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
4258                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4261     void setCoarseSampleOrderNV(
4262       VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
4263       ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
4264       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4265 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4266 
4267     //=== VK_NV_ray_tracing ===
4268 
4269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4270     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
4271                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
4272                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
4273                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
4274                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
4275                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
4276                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
4277                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
4278                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4279       VULKAN_HPP_NOEXCEPT;
4280 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4282     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
4283                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
4284                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
4285                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
4286                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
4287                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
4288                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
4289                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
4290                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4291       VULKAN_HPP_NOEXCEPT;
4292 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4293 
4294     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4295     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
4296                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
4297                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
4298                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4299       VULKAN_HPP_NOEXCEPT;
4300 
4301     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4302     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
4303                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
4304                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
4305                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
4306                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
4307                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
4308                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
4309                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
4310                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
4311                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
4312                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
4313                       uint32_t                         width,
4314                       uint32_t                         height,
4315                       uint32_t                         depth,
4316                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4317 
4318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4319     void writeAccelerationStructuresPropertiesNV(
4320       uint32_t                                              accelerationStructureCount,
4321       const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
4322       VULKAN_HPP_NAMESPACE::QueryType                       queryType,
4323       VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
4324       uint32_t                                              firstQuery,
4325       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4326 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4327     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4328     void writeAccelerationStructuresPropertiesNV(
4329       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
4330       VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
4331       VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
4332       uint32_t                                                                firstQuery,
4333       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4334 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4335 
4336     //=== VK_KHR_draw_indirect_count ===
4337 
4338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4339     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4340                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
4341                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4342                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4343                                uint32_t                         maxDrawCount,
4344                                uint32_t                         stride,
4345                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4346 
4347     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4348     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4349                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
4350                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4351                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4352                                       uint32_t                         maxDrawCount,
4353                                       uint32_t                         stride,
4354                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4355       VULKAN_HPP_NOEXCEPT;
4356 
4357     //=== VK_AMD_buffer_marker ===
4358 
4359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4360     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
4361                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
4362                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
4363                                uint32_t                                    marker,
4364                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4365 
4366     //=== VK_NV_mesh_shader ===
4367 
4368     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4369     void drawMeshTasksNV( uint32_t           taskCount,
4370                           uint32_t           firstTask,
4371                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4372 
4373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4374     void
4375       drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4376                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
4377                                uint32_t                         drawCount,
4378                                uint32_t                         stride,
4379                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4380 
4381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4382     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
4383                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
4384                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
4385                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4386                                        uint32_t                         maxDrawCount,
4387                                        uint32_t                         stride,
4388                                        Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4389       VULKAN_HPP_NOEXCEPT;
4390 
4391     //=== VK_NV_scissor_exclusive ===
4392 
4393     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4394     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
4395                                 uint32_t                             exclusiveScissorCount,
4396                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
4397                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4398 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4400     void setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
4401                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
4402                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4403 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4404 
4405     //=== VK_NV_device_diagnostic_checkpoints ===
4406 
4407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4408     void setCheckpointNV( const void *       pCheckpointMarker,
4409                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4410 
4411     //=== VK_INTEL_performance_query ===
4412 
4413     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4414     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
4415       const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
4416       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4417 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4418     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4419     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4420       setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,
4421                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4422 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4423 
4424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4425     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(
4426       const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
4427       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4429     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4430     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4431       setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,
4432                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4433 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4434 
4435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4436     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(
4437       const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
4438       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4439 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4441     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4442       setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,
4443                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4444 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4445 
4446     //=== VK_KHR_fragment_shading_rate ===
4447 
4448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4449     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
4450                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4451                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4452       VULKAN_HPP_NOEXCEPT;
4453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4455     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D &                       fragmentSize,
4456                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4457                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4458       VULKAN_HPP_NOEXCEPT;
4459 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4460 
4461     //=== VK_EXT_line_rasterization ===
4462 
4463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4464     void setLineStippleEXT( uint32_t           lineStippleFactor,
4465                             uint16_t           lineStipplePattern,
4466                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4467 
4468     //=== VK_EXT_extended_dynamic_state ===
4469 
4470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4471     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
4472                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4473 
4474     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4475     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
4476                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4477 
4478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4479     void
4480       setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
4481                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4482 
4483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4484     void
4485       setViewportWithCountEXT( uint32_t                               viewportCount,
4486                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4487                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4488 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4490     void
4491       setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4492                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4493 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4494 
4495     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4496     void
4497       setScissorWithCountEXT( uint32_t                             scissorCount,
4498                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4499                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4502     void
4503       setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4504                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4505 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4506 
4507     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4508     void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
4509                                 uint32_t                                 bindingCount,
4510                                 const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
4511                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4512                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4513                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4514                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4515 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4517     void bindVertexBuffers2EXT(
4518       uint32_t                                                           firstBinding,
4519       ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &             buffers,
4520       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const &         offsets,
4521       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4522       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4523       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4524 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4525 
4526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4527     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
4528                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4529 
4530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4531     void
4532       setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
4533                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4534 
4535     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4536     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
4537                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4538 
4539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4540     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
4541                                       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4542       VULKAN_HPP_NOEXCEPT;
4543 
4544     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4545     void
4546       setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
4547                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4548 
4549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4550     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4551                           VULKAN_HPP_NAMESPACE::StencilOp        failOp,
4552                           VULKAN_HPP_NAMESPACE::StencilOp        passOp,
4553                           VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
4554                           VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
4555                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4556 
4557     //=== VK_NV_device_generated_commands ===
4558 
4559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4560     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4561                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4562       VULKAN_HPP_NOEXCEPT;
4563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4565     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
4566                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4567       VULKAN_HPP_NOEXCEPT;
4568 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4569 
4570     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4571     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
4572                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4573                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4574       VULKAN_HPP_NOEXCEPT;
4575 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4576     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4577     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
4578                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
4579                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4580       VULKAN_HPP_NOEXCEPT;
4581 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4582 
4583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4584     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
4585                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
4586                                     uint32_t                                groupIndex,
4587                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4588       VULKAN_HPP_NOEXCEPT;
4589 
4590 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4591     //=== VK_KHR_video_encode_queue ===
4592 
4593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4594     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
4595                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4596 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4598     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
4599                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4600 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4601 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
4602 
4603     //=== VK_KHR_synchronization2 ===
4604 
4605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4606     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
4607                        const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
4608                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4609 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4611     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
4612                        const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo,
4613                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4614 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4615 
4616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4617     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
4618                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
4619                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4620 
4621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4622     void waitEvents2KHR( uint32_t                                        eventCount,
4623                          const VULKAN_HPP_NAMESPACE::Event *             pEvents,
4624                          const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
4625                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4626 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4627     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4628     void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
4629                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
4630                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4631       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4632 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4633 
4634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4635     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
4636                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4637 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4639     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo,
4640                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4641 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4642 
4643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4644     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
4645                              VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
4646                              uint32_t                                     query,
4647                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4648 
4649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4650     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
4651                                 VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
4652                                 VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
4653                                 uint32_t                                     marker,
4654                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4655 
4656     //=== VK_NV_fragment_shading_rate_enums ===
4657 
4658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4659     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
4660                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4661                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4662       VULKAN_HPP_NOEXCEPT;
4663 
4664     //=== VK_KHR_copy_commands2 ===
4665 
4666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4667     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
4668                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4669 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4671     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR & copyBufferInfo,
4672                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4673 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4674 
4675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4676     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
4677                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4678 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4679     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4680     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR & copyImageInfo,
4681                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4682 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4683 
4684     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4685     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
4686                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4689     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
4690                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4691 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4692 
4693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4694     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
4695                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4696 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4698     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
4699                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4700 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4701 
4702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4703     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
4704                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4706     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4707     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR & blitImageInfo,
4708                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4709 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4710 
4711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4712     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
4713                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4715     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4716     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR & resolveImageInfo,
4717                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4718 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4719 
4720     //=== VK_KHR_ray_tracing_pipeline ===
4721 
4722     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4723     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
4724                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
4725                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
4726                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
4727                        uint32_t                                                    width,
4728                        uint32_t                                                    height,
4729                        uint32_t                                                    depth,
4730                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4733     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
4734                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
4735                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
4736                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
4737                        uint32_t                                                    width,
4738                        uint32_t                                                    height,
4739                        uint32_t                                                    depth,
4740                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4741 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4742 
4743     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4744     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
4745                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
4746                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
4747                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
4748                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
4749                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4750 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4752     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
4753                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
4754                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
4755                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
4756                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
4757                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4758 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4759 
4760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4761     void setRayTracingPipelineStackSizeKHR( uint32_t           pipelineStackSize,
4762                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4763       VULKAN_HPP_NOEXCEPT;
4764 
4765     //=== VK_EXT_vertex_input_dynamic_state ===
4766 
4767     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4768     void
4769       setVertexInputEXT( uint32_t                                                        vertexBindingDescriptionCount,
4770                          const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
4771                          uint32_t vertexAttributeDescriptionCount,
4772                          const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
4773                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4776     void setVertexInputEXT(
4777       ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
4778       ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
4779       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4780 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4781 
4782     //=== VK_HUAWEI_subpass_shading ===
4783 
4784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4785     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4786 
4787     //=== VK_HUAWEI_invocation_mask ===
4788 
4789     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4790     void
4791       bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView   imageView,
4792                                 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
4793                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4794 
4795     //=== VK_EXT_extended_dynamic_state2 ===
4796 
4797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4798     void
4799       setPatchControlPointsEXT( uint32_t           patchControlPoints,
4800                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4801 
4802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4803     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
4804                                         Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4805       VULKAN_HPP_NOEXCEPT;
4806 
4807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4808     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
4809                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4810 
4811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4812     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
4813                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4814 
4815     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4816     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
4817                                        Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4818       VULKAN_HPP_NOEXCEPT;
4819 
4820     //=== VK_EXT_color_write_enable ===
4821 
4822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4823     void
4824       setColorWriteEnableEXT( uint32_t                             attachmentCount,
4825                               const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
4826                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4827 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4828     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4829     void
4830       setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
4831                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4832 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4833 
4834     //=== VK_EXT_multi_draw ===
4835 
4836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4837     void drawMultiEXT( uint32_t                                       drawCount,
4838                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
4839                        uint32_t                                       instanceCount,
4840                        uint32_t                                       firstInstance,
4841                        uint32_t                                       stride,
4842                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4843 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4844     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4845     void drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
4846                        uint32_t                                                         instanceCount,
4847                        uint32_t                                                         firstInstance,
4848                        uint32_t                                                         stride,
4849                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4850 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4851 
4852     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4853     void drawMultiIndexedEXT( uint32_t                                              drawCount,
4854                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
4855                               uint32_t                                              instanceCount,
4856                               uint32_t                                              firstInstance,
4857                               uint32_t                                              stride,
4858                               const int32_t *                                       pVertexOffset,
4859                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4862     void drawMultiIndexedEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
4863                               uint32_t                                                                instanceCount,
4864                               uint32_t                                                                firstInstance,
4865                               uint32_t                                                                stride,
4866                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4867                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4868 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4869 
operator VkCommandBuffer() const4870     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
4871     {
4872       return m_commandBuffer;
4873     }
4874 
operator bool() const4875     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4876     {
4877       return m_commandBuffer != VK_NULL_HANDLE;
4878     }
4879 
operator !() const4880     bool operator!() const VULKAN_HPP_NOEXCEPT
4881     {
4882       return m_commandBuffer == VK_NULL_HANDLE;
4883     }
4884 
4885   private:
4886     VkCommandBuffer m_commandBuffer = {};
4887   };
4888   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ),
4889                             "handle and wrapper have different size!" );
4890   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandBuffer>::value,
4891                             "CommandBuffer is not nothrow_move_constructible!" );
4892 
4893   template <>
4894   struct VULKAN_HPP_DEPRECATED(
4895     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandBuffer>
4896   {
4897     using type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4898   };
4899 
4900   template <>
4901   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
4902   {
4903     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4904   };
4905 
4906   template <>
4907   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4908                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
4909   {
4910     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4911   };
4912 
4913   template <>
4914   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
4915   {
4916     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4917   };
4918 
4919   class DeviceMemory
4920   {
4921   public:
4922     using CType      = VkDeviceMemory;
4923     using NativeType = VkDeviceMemory;
4924 
4925     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4926       VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
4927     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4928       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
4929 
4930   public:
4931     VULKAN_HPP_CONSTEXPR         DeviceMemory() = default;
DeviceMemory(std::nullptr_t)4932     VULKAN_HPP_CONSTEXPR         DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DeviceMemory(VkDeviceMemory deviceMemory)4933     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
4934       : m_deviceMemory( deviceMemory )
4935     {}
4936 
4937 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeviceMemory deviceMemory)4938     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
4939     {
4940       m_deviceMemory = deviceMemory;
4941       return *this;
4942     }
4943 #endif
4944 
operator =(std::nullptr_t)4945     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4946     {
4947       m_deviceMemory = {};
4948       return *this;
4949     }
4950 
4951 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4952     auto operator<=>( DeviceMemory const & ) const = default;
4953 #else
operator ==(DeviceMemory const & rhs) const4954     bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4955     {
4956       return m_deviceMemory == rhs.m_deviceMemory;
4957     }
4958 
operator !=(DeviceMemory const & rhs) const4959     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4960     {
4961       return m_deviceMemory != rhs.m_deviceMemory;
4962     }
4963 
operator <(DeviceMemory const & rhs) const4964     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4965     {
4966       return m_deviceMemory < rhs.m_deviceMemory;
4967     }
4968 #endif
4969 
operator VkDeviceMemory() const4970     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
4971     {
4972       return m_deviceMemory;
4973     }
4974 
operator bool() const4975     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4976     {
4977       return m_deviceMemory != VK_NULL_HANDLE;
4978     }
4979 
operator !() const4980     bool operator!() const VULKAN_HPP_NOEXCEPT
4981     {
4982       return m_deviceMemory == VK_NULL_HANDLE;
4983     }
4984 
4985   private:
4986     VkDeviceMemory m_deviceMemory = {};
4987   };
4988   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ),
4989                             "handle and wrapper have different size!" );
4990   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceMemory>::value,
4991                             "DeviceMemory is not nothrow_move_constructible!" );
4992 
4993   template <>
4994   struct VULKAN_HPP_DEPRECATED(
4995     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeviceMemory>
4996   {
4997     using type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4998   };
4999 
5000   template <>
5001   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
5002   {
5003     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
5004   };
5005 
5006   template <>
5007   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5008                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
5009   {
5010     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
5011   };
5012 
5013   template <>
5014   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
5015   {
5016     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5017   };
5018 
5019 #if defined( VK_ENABLE_BETA_EXTENSIONS )
5020   class VideoSessionKHR
5021   {
5022   public:
5023     using CType      = VkVideoSessionKHR;
5024     using NativeType = VkVideoSessionKHR;
5025 
5026     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5027       VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
5028     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5029       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5030 
5031   public:
5032     VULKAN_HPP_CONSTEXPR         VideoSessionKHR() = default;
VideoSessionKHR(std::nullptr_t)5033     VULKAN_HPP_CONSTEXPR         VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)5034     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
5035       : m_videoSessionKHR( videoSessionKHR )
5036     {}
5037 
5038 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionKHR videoSessionKHR)5039     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
5040     {
5041       m_videoSessionKHR = videoSessionKHR;
5042       return *this;
5043     }
5044 #  endif
5045 
operator =(std::nullptr_t)5046     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5047     {
5048       m_videoSessionKHR = {};
5049       return *this;
5050     }
5051 
5052 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5053     auto operator<=>( VideoSessionKHR const & ) const = default;
5054 #  else
operator ==(VideoSessionKHR const & rhs) const5055     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5056     {
5057       return m_videoSessionKHR == rhs.m_videoSessionKHR;
5058     }
5059 
operator !=(VideoSessionKHR const & rhs) const5060     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5061     {
5062       return m_videoSessionKHR != rhs.m_videoSessionKHR;
5063     }
5064 
operator <(VideoSessionKHR const & rhs) const5065     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5066     {
5067       return m_videoSessionKHR < rhs.m_videoSessionKHR;
5068     }
5069 #  endif
5070 
operator VkVideoSessionKHR() const5071     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
5072     {
5073       return m_videoSessionKHR;
5074     }
5075 
operator bool() const5076     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5077     {
5078       return m_videoSessionKHR != VK_NULL_HANDLE;
5079     }
5080 
operator !() const5081     bool operator!() const VULKAN_HPP_NOEXCEPT
5082     {
5083       return m_videoSessionKHR == VK_NULL_HANDLE;
5084     }
5085 
5086   private:
5087     VkVideoSessionKHR m_videoSessionKHR = {};
5088   };
5089   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ),
5090                             "handle and wrapper have different size!" );
5091   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::value,
5092                             "VideoSessionKHR is not nothrow_move_constructible!" );
5093 
5094   template <>
5095   struct VULKAN_HPP_DEPRECATED(
5096     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionKHR>
5097   {
5098     using type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5099   };
5100 
5101   template <>
5102   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
5103   {
5104     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5105   };
5106 
5107   template <>
5108   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
5109   {
5110     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5111   };
5112 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5113 
5114   class DeferredOperationKHR
5115   {
5116   public:
5117     using CType      = VkDeferredOperationKHR;
5118     using NativeType = VkDeferredOperationKHR;
5119 
5120     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5121       VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
5122     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5123       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5124 
5125   public:
5126     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR() = default;
DeferredOperationKHR(std::nullptr_t)5127     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)5128     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5129       : m_deferredOperationKHR( deferredOperationKHR )
5130     {}
5131 
5132 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeferredOperationKHR deferredOperationKHR)5133     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5134     {
5135       m_deferredOperationKHR = deferredOperationKHR;
5136       return *this;
5137     }
5138 #endif
5139 
operator =(std::nullptr_t)5140     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5141     {
5142       m_deferredOperationKHR = {};
5143       return *this;
5144     }
5145 
5146 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5147     auto operator<=>( DeferredOperationKHR const & ) const = default;
5148 #else
operator ==(DeferredOperationKHR const & rhs) const5149     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5150     {
5151       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
5152     }
5153 
operator !=(DeferredOperationKHR const & rhs) const5154     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5155     {
5156       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
5157     }
5158 
operator <(DeferredOperationKHR const & rhs) const5159     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5160     {
5161       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
5162     }
5163 #endif
5164 
operator VkDeferredOperationKHR() const5165     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
5166     {
5167       return m_deferredOperationKHR;
5168     }
5169 
operator bool() const5170     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5171     {
5172       return m_deferredOperationKHR != VK_NULL_HANDLE;
5173     }
5174 
operator !() const5175     bool operator!() const VULKAN_HPP_NOEXCEPT
5176     {
5177       return m_deferredOperationKHR == VK_NULL_HANDLE;
5178     }
5179 
5180   private:
5181     VkDeferredOperationKHR m_deferredOperationKHR = {};
5182   };
5183   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ),
5184                             "handle and wrapper have different size!" );
5185   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::value,
5186                             "DeferredOperationKHR is not nothrow_move_constructible!" );
5187 
5188   template <>
5189   struct VULKAN_HPP_DEPRECATED(
5190     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeferredOperationKHR>
5191   {
5192     using type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
5193   };
5194 
5195   template <>
5196   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
5197   {
5198     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
5199   };
5200 
5201   template <>
5202   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
5203   {
5204     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5205   };
5206 
5207 #if defined( VK_USE_PLATFORM_FUCHSIA )
5208   class BufferCollectionFUCHSIA
5209   {
5210   public:
5211     using CType      = VkBufferCollectionFUCHSIA;
5212     using NativeType = VkBufferCollectionFUCHSIA;
5213 
5214     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5215       VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
5216     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5217       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
5218 
5219   public:
5220     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
BufferCollectionFUCHSIA(std::nullptr_t)5221     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5222     VULKAN_HPP_TYPESAFE_EXPLICIT
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)5223       BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5224       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
5225     {}
5226 
5227 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)5228     BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5229     {
5230       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
5231       return *this;
5232     }
5233 #  endif
5234 
operator =(std::nullptr_t)5235     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5236     {
5237       m_bufferCollectionFUCHSIA = {};
5238       return *this;
5239     }
5240 
5241 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5242     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
5243 #  else
operator ==(BufferCollectionFUCHSIA const & rhs) const5244     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5245     {
5246       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
5247     }
5248 
operator !=(BufferCollectionFUCHSIA const & rhs) const5249     bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5250     {
5251       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
5252     }
5253 
operator <(BufferCollectionFUCHSIA const & rhs) const5254     bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5255     {
5256       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
5257     }
5258 #  endif
5259 
operator VkBufferCollectionFUCHSIA() const5260     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
5261     {
5262       return m_bufferCollectionFUCHSIA;
5263     }
5264 
operator bool() const5265     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5266     {
5267       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
5268     }
5269 
operator !() const5270     bool operator!() const VULKAN_HPP_NOEXCEPT
5271     {
5272       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
5273     }
5274 
5275   private:
5276     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
5277   };
5278   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA ) ==
5279                               sizeof( VkBufferCollectionFUCHSIA ),
5280                             "handle and wrapper have different size!" );
5281   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::value,
5282                             "BufferCollectionFUCHSIA is not nothrow_move_constructible!" );
5283 
5284   template <>
5285   struct VULKAN_HPP_DEPRECATED(
5286     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBufferCollectionFUCHSIA>
5287   {
5288     using type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5289   };
5290 
5291   template <>
5292   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
5293   {
5294     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5295   };
5296 
5297   template <>
5298   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5299                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
5300   {
5301     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5302   };
5303 
5304   template <>
5305   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
5306   {
5307     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5308   };
5309 #endif /*VK_USE_PLATFORM_FUCHSIA*/
5310 
5311   class BufferView
5312   {
5313   public:
5314     using CType      = VkBufferView;
5315     using NativeType = VkBufferView;
5316 
5317     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5318       VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
5319     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5320       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
5321 
5322   public:
5323     VULKAN_HPP_CONSTEXPR         BufferView() = default;
BufferView(std::nullptr_t)5324     VULKAN_HPP_CONSTEXPR         BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
BufferView(VkBufferView bufferView)5325     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView )
5326     {}
5327 
5328 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBufferView bufferView)5329     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
5330     {
5331       m_bufferView = bufferView;
5332       return *this;
5333     }
5334 #endif
5335 
operator =(std::nullptr_t)5336     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5337     {
5338       m_bufferView = {};
5339       return *this;
5340     }
5341 
5342 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5343     auto operator<=>( BufferView const & ) const = default;
5344 #else
operator ==(BufferView const & rhs) const5345     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5346     {
5347       return m_bufferView == rhs.m_bufferView;
5348     }
5349 
operator !=(BufferView const & rhs) const5350     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5351     {
5352       return m_bufferView != rhs.m_bufferView;
5353     }
5354 
operator <(BufferView const & rhs) const5355     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5356     {
5357       return m_bufferView < rhs.m_bufferView;
5358     }
5359 #endif
5360 
operator VkBufferView() const5361     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
5362     {
5363       return m_bufferView;
5364     }
5365 
operator bool() const5366     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5367     {
5368       return m_bufferView != VK_NULL_HANDLE;
5369     }
5370 
operator !() const5371     bool operator!() const VULKAN_HPP_NOEXCEPT
5372     {
5373       return m_bufferView == VK_NULL_HANDLE;
5374     }
5375 
5376   private:
5377     VkBufferView m_bufferView = {};
5378   };
5379   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ),
5380                             "handle and wrapper have different size!" );
5381   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferView>::value,
5382                             "BufferView is not nothrow_move_constructible!" );
5383 
5384   template <>
5385   struct VULKAN_HPP_DEPRECATED(
5386     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBufferView>
5387   {
5388     using type = VULKAN_HPP_NAMESPACE::BufferView;
5389   };
5390 
5391   template <>
5392   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
5393   {
5394     using Type = VULKAN_HPP_NAMESPACE::BufferView;
5395   };
5396 
5397   template <>
5398   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5399                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
5400   {
5401     using Type = VULKAN_HPP_NAMESPACE::BufferView;
5402   };
5403 
5404   template <>
5405   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
5406   {
5407     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5408   };
5409 
5410   class CommandPool
5411   {
5412   public:
5413     using CType      = VkCommandPool;
5414     using NativeType = VkCommandPool;
5415 
5416     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5417       VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
5418     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5419       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
5420 
5421   public:
5422     VULKAN_HPP_CONSTEXPR         CommandPool() = default;
CommandPool(std::nullptr_t)5423     VULKAN_HPP_CONSTEXPR         CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CommandPool(VkCommandPool commandPool)5424     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
5425       : m_commandPool( commandPool )
5426     {}
5427 
5428 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandPool commandPool)5429     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
5430     {
5431       m_commandPool = commandPool;
5432       return *this;
5433     }
5434 #endif
5435 
operator =(std::nullptr_t)5436     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5437     {
5438       m_commandPool = {};
5439       return *this;
5440     }
5441 
5442 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5443     auto operator<=>( CommandPool const & ) const = default;
5444 #else
operator ==(CommandPool const & rhs) const5445     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5446     {
5447       return m_commandPool == rhs.m_commandPool;
5448     }
5449 
operator !=(CommandPool const & rhs) const5450     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5451     {
5452       return m_commandPool != rhs.m_commandPool;
5453     }
5454 
operator <(CommandPool const & rhs) const5455     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5456     {
5457       return m_commandPool < rhs.m_commandPool;
5458     }
5459 #endif
5460 
operator VkCommandPool() const5461     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
5462     {
5463       return m_commandPool;
5464     }
5465 
operator bool() const5466     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5467     {
5468       return m_commandPool != VK_NULL_HANDLE;
5469     }
5470 
operator !() const5471     bool operator!() const VULKAN_HPP_NOEXCEPT
5472     {
5473       return m_commandPool == VK_NULL_HANDLE;
5474     }
5475 
5476   private:
5477     VkCommandPool m_commandPool = {};
5478   };
5479   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ),
5480                             "handle and wrapper have different size!" );
5481   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandPool>::value,
5482                             "CommandPool is not nothrow_move_constructible!" );
5483 
5484   template <>
5485   struct VULKAN_HPP_DEPRECATED(
5486     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandPool>
5487   {
5488     using type = VULKAN_HPP_NAMESPACE::CommandPool;
5489   };
5490 
5491   template <>
5492   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
5493   {
5494     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
5495   };
5496 
5497   template <>
5498   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5499                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
5500   {
5501     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
5502   };
5503 
5504   template <>
5505   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
5506   {
5507     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5508   };
5509 
5510   class PipelineCache
5511   {
5512   public:
5513     using CType      = VkPipelineCache;
5514     using NativeType = VkPipelineCache;
5515 
5516     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5517       VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
5518     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5519       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
5520 
5521   public:
5522     VULKAN_HPP_CONSTEXPR         PipelineCache() = default;
PipelineCache(std::nullptr_t)5523     VULKAN_HPP_CONSTEXPR         PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PipelineCache(VkPipelineCache pipelineCache)5524     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
5525       : m_pipelineCache( pipelineCache )
5526     {}
5527 
5528 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineCache pipelineCache)5529     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
5530     {
5531       m_pipelineCache = pipelineCache;
5532       return *this;
5533     }
5534 #endif
5535 
operator =(std::nullptr_t)5536     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5537     {
5538       m_pipelineCache = {};
5539       return *this;
5540     }
5541 
5542 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5543     auto operator<=>( PipelineCache const & ) const = default;
5544 #else
operator ==(PipelineCache const & rhs) const5545     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5546     {
5547       return m_pipelineCache == rhs.m_pipelineCache;
5548     }
5549 
operator !=(PipelineCache const & rhs) const5550     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5551     {
5552       return m_pipelineCache != rhs.m_pipelineCache;
5553     }
5554 
operator <(PipelineCache const & rhs) const5555     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5556     {
5557       return m_pipelineCache < rhs.m_pipelineCache;
5558     }
5559 #endif
5560 
operator VkPipelineCache() const5561     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
5562     {
5563       return m_pipelineCache;
5564     }
5565 
operator bool() const5566     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5567     {
5568       return m_pipelineCache != VK_NULL_HANDLE;
5569     }
5570 
operator !() const5571     bool operator!() const VULKAN_HPP_NOEXCEPT
5572     {
5573       return m_pipelineCache == VK_NULL_HANDLE;
5574     }
5575 
5576   private:
5577     VkPipelineCache m_pipelineCache = {};
5578   };
5579   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ),
5580                             "handle and wrapper have different size!" );
5581   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCache>::value,
5582                             "PipelineCache is not nothrow_move_constructible!" );
5583 
5584   template <>
5585   struct VULKAN_HPP_DEPRECATED(
5586     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineCache>
5587   {
5588     using type = VULKAN_HPP_NAMESPACE::PipelineCache;
5589   };
5590 
5591   template <>
5592   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
5593   {
5594     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5595   };
5596 
5597   template <>
5598   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5599                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
5600   {
5601     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5602   };
5603 
5604   template <>
5605   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
5606   {
5607     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5608   };
5609 
5610   class CuFunctionNVX
5611   {
5612   public:
5613     using CType      = VkCuFunctionNVX;
5614     using NativeType = VkCuFunctionNVX;
5615 
5616     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5617       VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
5618     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5619       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
5620 
5621   public:
5622     VULKAN_HPP_CONSTEXPR         CuFunctionNVX() = default;
CuFunctionNVX(std::nullptr_t)5623     VULKAN_HPP_CONSTEXPR         CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)5624     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5625       : m_cuFunctionNVX( cuFunctionNVX )
5626     {}
5627 
5628 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuFunctionNVX cuFunctionNVX)5629     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5630     {
5631       m_cuFunctionNVX = cuFunctionNVX;
5632       return *this;
5633     }
5634 #endif
5635 
operator =(std::nullptr_t)5636     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5637     {
5638       m_cuFunctionNVX = {};
5639       return *this;
5640     }
5641 
5642 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5643     auto operator<=>( CuFunctionNVX const & ) const = default;
5644 #else
operator ==(CuFunctionNVX const & rhs) const5645     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5646     {
5647       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
5648     }
5649 
operator !=(CuFunctionNVX const & rhs) const5650     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5651     {
5652       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
5653     }
5654 
operator <(CuFunctionNVX const & rhs) const5655     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5656     {
5657       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
5658     }
5659 #endif
5660 
operator VkCuFunctionNVX() const5661     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
5662     {
5663       return m_cuFunctionNVX;
5664     }
5665 
operator bool() const5666     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5667     {
5668       return m_cuFunctionNVX != VK_NULL_HANDLE;
5669     }
5670 
operator !() const5671     bool operator!() const VULKAN_HPP_NOEXCEPT
5672     {
5673       return m_cuFunctionNVX == VK_NULL_HANDLE;
5674     }
5675 
5676   private:
5677     VkCuFunctionNVX m_cuFunctionNVX = {};
5678   };
5679   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ),
5680                             "handle and wrapper have different size!" );
5681   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::value,
5682                             "CuFunctionNVX is not nothrow_move_constructible!" );
5683 
5684   template <>
5685   struct VULKAN_HPP_DEPRECATED(
5686     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuFunctionNVX>
5687   {
5688     using type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5689   };
5690 
5691   template <>
5692   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
5693   {
5694     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5695   };
5696 
5697   template <>
5698   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5699                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
5700   {
5701     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5702   };
5703 
5704   template <>
5705   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
5706   {
5707     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5708   };
5709 
5710   class CuModuleNVX
5711   {
5712   public:
5713     using CType      = VkCuModuleNVX;
5714     using NativeType = VkCuModuleNVX;
5715 
5716     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5717       VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
5718     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5719       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
5720 
5721   public:
5722     VULKAN_HPP_CONSTEXPR         CuModuleNVX() = default;
CuModuleNVX(std::nullptr_t)5723     VULKAN_HPP_CONSTEXPR         CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CuModuleNVX(VkCuModuleNVX cuModuleNVX)5724     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5725       : m_cuModuleNVX( cuModuleNVX )
5726     {}
5727 
5728 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuModuleNVX cuModuleNVX)5729     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5730     {
5731       m_cuModuleNVX = cuModuleNVX;
5732       return *this;
5733     }
5734 #endif
5735 
operator =(std::nullptr_t)5736     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5737     {
5738       m_cuModuleNVX = {};
5739       return *this;
5740     }
5741 
5742 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5743     auto operator<=>( CuModuleNVX const & ) const = default;
5744 #else
operator ==(CuModuleNVX const & rhs) const5745     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5746     {
5747       return m_cuModuleNVX == rhs.m_cuModuleNVX;
5748     }
5749 
operator !=(CuModuleNVX const & rhs) const5750     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5751     {
5752       return m_cuModuleNVX != rhs.m_cuModuleNVX;
5753     }
5754 
operator <(CuModuleNVX const & rhs) const5755     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5756     {
5757       return m_cuModuleNVX < rhs.m_cuModuleNVX;
5758     }
5759 #endif
5760 
operator VkCuModuleNVX() const5761     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
5762     {
5763       return m_cuModuleNVX;
5764     }
5765 
operator bool() const5766     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5767     {
5768       return m_cuModuleNVX != VK_NULL_HANDLE;
5769     }
5770 
operator !() const5771     bool operator!() const VULKAN_HPP_NOEXCEPT
5772     {
5773       return m_cuModuleNVX == VK_NULL_HANDLE;
5774     }
5775 
5776   private:
5777     VkCuModuleNVX m_cuModuleNVX = {};
5778   };
5779   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ),
5780                             "handle and wrapper have different size!" );
5781   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleNVX>::value,
5782                             "CuModuleNVX is not nothrow_move_constructible!" );
5783 
5784   template <>
5785   struct VULKAN_HPP_DEPRECATED(
5786     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuModuleNVX>
5787   {
5788     using type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5789   };
5790 
5791   template <>
5792   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
5793   {
5794     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5795   };
5796 
5797   template <>
5798   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5799                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
5800   {
5801     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5802   };
5803 
5804   template <>
5805   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
5806   {
5807     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5808   };
5809 
5810   class DescriptorPool
5811   {
5812   public:
5813     using CType      = VkDescriptorPool;
5814     using NativeType = VkDescriptorPool;
5815 
5816     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5817       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
5818     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5819       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
5820 
5821   public:
5822     VULKAN_HPP_CONSTEXPR         DescriptorPool() = default;
DescriptorPool(std::nullptr_t)5823     VULKAN_HPP_CONSTEXPR         DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorPool(VkDescriptorPool descriptorPool)5824     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5825       : m_descriptorPool( descriptorPool )
5826     {}
5827 
5828 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorPool descriptorPool)5829     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5830     {
5831       m_descriptorPool = descriptorPool;
5832       return *this;
5833     }
5834 #endif
5835 
operator =(std::nullptr_t)5836     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5837     {
5838       m_descriptorPool = {};
5839       return *this;
5840     }
5841 
5842 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5843     auto operator<=>( DescriptorPool const & ) const = default;
5844 #else
operator ==(DescriptorPool const & rhs) const5845     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5846     {
5847       return m_descriptorPool == rhs.m_descriptorPool;
5848     }
5849 
operator !=(DescriptorPool const & rhs) const5850     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5851     {
5852       return m_descriptorPool != rhs.m_descriptorPool;
5853     }
5854 
operator <(DescriptorPool const & rhs) const5855     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5856     {
5857       return m_descriptorPool < rhs.m_descriptorPool;
5858     }
5859 #endif
5860 
operator VkDescriptorPool() const5861     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
5862     {
5863       return m_descriptorPool;
5864     }
5865 
operator bool() const5866     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5867     {
5868       return m_descriptorPool != VK_NULL_HANDLE;
5869     }
5870 
operator !() const5871     bool operator!() const VULKAN_HPP_NOEXCEPT
5872     {
5873       return m_descriptorPool == VK_NULL_HANDLE;
5874     }
5875 
5876   private:
5877     VkDescriptorPool m_descriptorPool = {};
5878   };
5879   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ),
5880                             "handle and wrapper have different size!" );
5881   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPool>::value,
5882                             "DescriptorPool is not nothrow_move_constructible!" );
5883 
5884   template <>
5885   struct VULKAN_HPP_DEPRECATED(
5886     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorPool>
5887   {
5888     using type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5889   };
5890 
5891   template <>
5892   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
5893   {
5894     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5895   };
5896 
5897   template <>
5898   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5899                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
5900   {
5901     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5902   };
5903 
5904   template <>
5905   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
5906   {
5907     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5908   };
5909 
5910   class DescriptorSetLayout
5911   {
5912   public:
5913     using CType      = VkDescriptorSetLayout;
5914     using NativeType = VkDescriptorSetLayout;
5915 
5916     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5917       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
5918     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5919       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
5920 
5921   public:
5922     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout() = default;
DescriptorSetLayout(std::nullptr_t)5923     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)5924     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5925       : m_descriptorSetLayout( descriptorSetLayout )
5926     {}
5927 
5928 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSetLayout descriptorSetLayout)5929     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5930     {
5931       m_descriptorSetLayout = descriptorSetLayout;
5932       return *this;
5933     }
5934 #endif
5935 
operator =(std::nullptr_t)5936     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5937     {
5938       m_descriptorSetLayout = {};
5939       return *this;
5940     }
5941 
5942 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5943     auto operator<=>( DescriptorSetLayout const & ) const = default;
5944 #else
operator ==(DescriptorSetLayout const & rhs) const5945     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5946     {
5947       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
5948     }
5949 
operator !=(DescriptorSetLayout const & rhs) const5950     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5951     {
5952       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
5953     }
5954 
operator <(DescriptorSetLayout const & rhs) const5955     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5956     {
5957       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
5958     }
5959 #endif
5960 
operator VkDescriptorSetLayout() const5961     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
5962     {
5963       return m_descriptorSetLayout;
5964     }
5965 
operator bool() const5966     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5967     {
5968       return m_descriptorSetLayout != VK_NULL_HANDLE;
5969     }
5970 
operator !() const5971     bool operator!() const VULKAN_HPP_NOEXCEPT
5972     {
5973       return m_descriptorSetLayout == VK_NULL_HANDLE;
5974     }
5975 
5976   private:
5977     VkDescriptorSetLayout m_descriptorSetLayout = {};
5978   };
5979   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ),
5980                             "handle and wrapper have different size!" );
5981   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::value,
5982                             "DescriptorSetLayout is not nothrow_move_constructible!" );
5983 
5984   template <>
5985   struct VULKAN_HPP_DEPRECATED(
5986     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSetLayout>
5987   {
5988     using type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5989   };
5990 
5991   template <>
5992   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
5993   {
5994     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5995   };
5996 
5997   template <>
5998   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5999                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
6000   {
6001     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
6002   };
6003 
6004   template <>
6005   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
6006   {
6007     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6008   };
6009 
6010   class Framebuffer
6011   {
6012   public:
6013     using CType      = VkFramebuffer;
6014     using NativeType = VkFramebuffer;
6015 
6016     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6017       VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
6018     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6019       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
6020 
6021   public:
6022     VULKAN_HPP_CONSTEXPR         Framebuffer() = default;
Framebuffer(std::nullptr_t)6023     VULKAN_HPP_CONSTEXPR         Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Framebuffer(VkFramebuffer framebuffer)6024     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
6025       : m_framebuffer( framebuffer )
6026     {}
6027 
6028 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFramebuffer framebuffer)6029     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
6030     {
6031       m_framebuffer = framebuffer;
6032       return *this;
6033     }
6034 #endif
6035 
operator =(std::nullptr_t)6036     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6037     {
6038       m_framebuffer = {};
6039       return *this;
6040     }
6041 
6042 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6043     auto operator<=>( Framebuffer const & ) const = default;
6044 #else
operator ==(Framebuffer const & rhs) const6045     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6046     {
6047       return m_framebuffer == rhs.m_framebuffer;
6048     }
6049 
operator !=(Framebuffer const & rhs) const6050     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6051     {
6052       return m_framebuffer != rhs.m_framebuffer;
6053     }
6054 
operator <(Framebuffer const & rhs) const6055     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6056     {
6057       return m_framebuffer < rhs.m_framebuffer;
6058     }
6059 #endif
6060 
operator VkFramebuffer() const6061     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
6062     {
6063       return m_framebuffer;
6064     }
6065 
operator bool() const6066     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6067     {
6068       return m_framebuffer != VK_NULL_HANDLE;
6069     }
6070 
operator !() const6071     bool operator!() const VULKAN_HPP_NOEXCEPT
6072     {
6073       return m_framebuffer == VK_NULL_HANDLE;
6074     }
6075 
6076   private:
6077     VkFramebuffer m_framebuffer = {};
6078   };
6079   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ),
6080                             "handle and wrapper have different size!" );
6081   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Framebuffer>::value,
6082                             "Framebuffer is not nothrow_move_constructible!" );
6083 
6084   template <>
6085   struct VULKAN_HPP_DEPRECATED(
6086     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFramebuffer>
6087   {
6088     using type = VULKAN_HPP_NAMESPACE::Framebuffer;
6089   };
6090 
6091   template <>
6092   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
6093   {
6094     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6095   };
6096 
6097   template <>
6098   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6099                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
6100   {
6101     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6102   };
6103 
6104   template <>
6105   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
6106   {
6107     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6108   };
6109 
6110   class IndirectCommandsLayoutNV
6111   {
6112   public:
6113     using CType      = VkIndirectCommandsLayoutNV;
6114     using NativeType = VkIndirectCommandsLayoutNV;
6115 
6116     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6117       VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
6118     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6119       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6120 
6121   public:
6122     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
IndirectCommandsLayoutNV(std::nullptr_t)6123     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6124     VULKAN_HPP_TYPESAFE_EXPLICIT
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6125       IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6126       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
6127     {}
6128 
6129 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6130     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6131     {
6132       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
6133       return *this;
6134     }
6135 #endif
6136 
operator =(std::nullptr_t)6137     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6138     {
6139       m_indirectCommandsLayoutNV = {};
6140       return *this;
6141     }
6142 
6143 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6144     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
6145 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const6146     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6147     {
6148       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
6149     }
6150 
operator !=(IndirectCommandsLayoutNV const & rhs) const6151     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6152     {
6153       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
6154     }
6155 
operator <(IndirectCommandsLayoutNV const & rhs) const6156     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6157     {
6158       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
6159     }
6160 #endif
6161 
operator VkIndirectCommandsLayoutNV() const6162     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
6163     {
6164       return m_indirectCommandsLayoutNV;
6165     }
6166 
operator bool() const6167     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6168     {
6169       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
6170     }
6171 
operator !() const6172     bool operator!() const VULKAN_HPP_NOEXCEPT
6173     {
6174       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
6175     }
6176 
6177   private:
6178     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
6179   };
6180   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) ==
6181                               sizeof( VkIndirectCommandsLayoutNV ),
6182                             "handle and wrapper have different size!" );
6183   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::value,
6184                             "IndirectCommandsLayoutNV is not nothrow_move_constructible!" );
6185 
6186   template <>
6187   struct VULKAN_HPP_DEPRECATED(
6188     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eIndirectCommandsLayoutNV>
6189   {
6190     using type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
6191   };
6192 
6193   template <>
6194   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
6195   {
6196     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
6197   };
6198 
6199   template <>
6200   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
6201   {
6202     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6203   };
6204 
6205   class PrivateDataSlotEXT
6206   {
6207   public:
6208     using CType      = VkPrivateDataSlotEXT;
6209     using NativeType = VkPrivateDataSlotEXT;
6210 
6211     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6212       VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT;
6213     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6214       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6215 
6216   public:
6217     VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT() = default;
PrivateDataSlotEXT(std::nullptr_t)6218     VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PrivateDataSlotEXT(VkPrivateDataSlotEXT privateDataSlotEXT)6219     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlotEXT( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
6220       : m_privateDataSlotEXT( privateDataSlotEXT )
6221     {}
6222 
6223 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPrivateDataSlotEXT privateDataSlotEXT)6224     PrivateDataSlotEXT & operator=( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
6225     {
6226       m_privateDataSlotEXT = privateDataSlotEXT;
6227       return *this;
6228     }
6229 #endif
6230 
operator =(std::nullptr_t)6231     PrivateDataSlotEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6232     {
6233       m_privateDataSlotEXT = {};
6234       return *this;
6235     }
6236 
6237 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6238     auto operator<=>( PrivateDataSlotEXT const & ) const = default;
6239 #else
operator ==(PrivateDataSlotEXT const & rhs) const6240     bool operator==( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6241     {
6242       return m_privateDataSlotEXT == rhs.m_privateDataSlotEXT;
6243     }
6244 
operator !=(PrivateDataSlotEXT const & rhs) const6245     bool operator!=( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6246     {
6247       return m_privateDataSlotEXT != rhs.m_privateDataSlotEXT;
6248     }
6249 
operator <(PrivateDataSlotEXT const & rhs) const6250     bool operator<( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6251     {
6252       return m_privateDataSlotEXT < rhs.m_privateDataSlotEXT;
6253     }
6254 #endif
6255 
operator VkPrivateDataSlotEXT() const6256     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlotEXT() const VULKAN_HPP_NOEXCEPT
6257     {
6258       return m_privateDataSlotEXT;
6259     }
6260 
operator bool() const6261     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6262     {
6263       return m_privateDataSlotEXT != VK_NULL_HANDLE;
6264     }
6265 
operator !() const6266     bool operator!() const VULKAN_HPP_NOEXCEPT
6267     {
6268       return m_privateDataSlotEXT == VK_NULL_HANDLE;
6269     }
6270 
6271   private:
6272     VkPrivateDataSlotEXT m_privateDataSlotEXT = {};
6273   };
6274   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ),
6275                             "handle and wrapper have different size!" );
6276   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::value,
6277                             "PrivateDataSlotEXT is not nothrow_move_constructible!" );
6278 
6279   template <>
6280   struct VULKAN_HPP_DEPRECATED(
6281     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePrivateDataSlotEXT>
6282   {
6283     using type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
6284   };
6285 
6286   template <>
6287   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT>
6288   {
6289     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
6290   };
6291 
6292   template <>
6293   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
6294   {
6295     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6296   };
6297 
6298   class RenderPass
6299   {
6300   public:
6301     using CType      = VkRenderPass;
6302     using NativeType = VkRenderPass;
6303 
6304     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6305       VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
6306     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6307       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
6308 
6309   public:
6310     VULKAN_HPP_CONSTEXPR         RenderPass() = default;
RenderPass(std::nullptr_t)6311     VULKAN_HPP_CONSTEXPR         RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
RenderPass(VkRenderPass renderPass)6312     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass )
6313     {}
6314 
6315 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkRenderPass renderPass)6316     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
6317     {
6318       m_renderPass = renderPass;
6319       return *this;
6320     }
6321 #endif
6322 
operator =(std::nullptr_t)6323     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6324     {
6325       m_renderPass = {};
6326       return *this;
6327     }
6328 
6329 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6330     auto operator<=>( RenderPass const & ) const = default;
6331 #else
operator ==(RenderPass const & rhs) const6332     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6333     {
6334       return m_renderPass == rhs.m_renderPass;
6335     }
6336 
operator !=(RenderPass const & rhs) const6337     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6338     {
6339       return m_renderPass != rhs.m_renderPass;
6340     }
6341 
operator <(RenderPass const & rhs) const6342     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6343     {
6344       return m_renderPass < rhs.m_renderPass;
6345     }
6346 #endif
6347 
operator VkRenderPass() const6348     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
6349     {
6350       return m_renderPass;
6351     }
6352 
operator bool() const6353     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6354     {
6355       return m_renderPass != VK_NULL_HANDLE;
6356     }
6357 
operator !() const6358     bool operator!() const VULKAN_HPP_NOEXCEPT
6359     {
6360       return m_renderPass == VK_NULL_HANDLE;
6361     }
6362 
6363   private:
6364     VkRenderPass m_renderPass = {};
6365   };
6366   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ),
6367                             "handle and wrapper have different size!" );
6368   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPass>::value,
6369                             "RenderPass is not nothrow_move_constructible!" );
6370 
6371   template <>
6372   struct VULKAN_HPP_DEPRECATED(
6373     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eRenderPass>
6374   {
6375     using type = VULKAN_HPP_NAMESPACE::RenderPass;
6376   };
6377 
6378   template <>
6379   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
6380   {
6381     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
6382   };
6383 
6384   template <>
6385   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6386                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
6387   {
6388     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
6389   };
6390 
6391   template <>
6392   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
6393   {
6394     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6395   };
6396 
6397   class Sampler
6398   {
6399   public:
6400     using CType      = VkSampler;
6401     using NativeType = VkSampler;
6402 
6403     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6404       VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
6405     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6406       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
6407 
6408   public:
6409     VULKAN_HPP_CONSTEXPR         Sampler() = default;
Sampler(std::nullptr_t)6410     VULKAN_HPP_CONSTEXPR         Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Sampler(VkSampler sampler)6411     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
6412 
6413 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSampler sampler)6414     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
6415     {
6416       m_sampler = sampler;
6417       return *this;
6418     }
6419 #endif
6420 
operator =(std::nullptr_t)6421     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6422     {
6423       m_sampler = {};
6424       return *this;
6425     }
6426 
6427 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6428     auto operator<=>( Sampler const & ) const = default;
6429 #else
operator ==(Sampler const & rhs) const6430     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6431     {
6432       return m_sampler == rhs.m_sampler;
6433     }
6434 
operator !=(Sampler const & rhs) const6435     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6436     {
6437       return m_sampler != rhs.m_sampler;
6438     }
6439 
operator <(Sampler const & rhs) const6440     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6441     {
6442       return m_sampler < rhs.m_sampler;
6443     }
6444 #endif
6445 
operator VkSampler() const6446     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
6447     {
6448       return m_sampler;
6449     }
6450 
operator bool() const6451     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6452     {
6453       return m_sampler != VK_NULL_HANDLE;
6454     }
6455 
operator !() const6456     bool operator!() const VULKAN_HPP_NOEXCEPT
6457     {
6458       return m_sampler == VK_NULL_HANDLE;
6459     }
6460 
6461   private:
6462     VkSampler m_sampler = {};
6463   };
6464   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ),
6465                             "handle and wrapper have different size!" );
6466   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Sampler>::value,
6467                             "Sampler is not nothrow_move_constructible!" );
6468 
6469   template <>
6470   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSampler>
6471   {
6472     using type = VULKAN_HPP_NAMESPACE::Sampler;
6473   };
6474 
6475   template <>
6476   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
6477   {
6478     using Type = VULKAN_HPP_NAMESPACE::Sampler;
6479   };
6480 
6481   template <>
6482   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6483                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
6484   {
6485     using Type = VULKAN_HPP_NAMESPACE::Sampler;
6486   };
6487 
6488   template <>
6489   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
6490   {
6491     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6492   };
6493 
6494   class SamplerYcbcrConversion
6495   {
6496   public:
6497     using CType      = VkSamplerYcbcrConversion;
6498     using NativeType = VkSamplerYcbcrConversion;
6499 
6500     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6501       VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
6502     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6503       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
6504 
6505   public:
6506     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
SamplerYcbcrConversion(std::nullptr_t)6507     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6508     VULKAN_HPP_TYPESAFE_EXPLICIT
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)6509       SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6510       : m_samplerYcbcrConversion( samplerYcbcrConversion )
6511     {}
6512 
6513 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)6514     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6515     {
6516       m_samplerYcbcrConversion = samplerYcbcrConversion;
6517       return *this;
6518     }
6519 #endif
6520 
operator =(std::nullptr_t)6521     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6522     {
6523       m_samplerYcbcrConversion = {};
6524       return *this;
6525     }
6526 
6527 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6528     auto operator<=>( SamplerYcbcrConversion const & ) const = default;
6529 #else
operator ==(SamplerYcbcrConversion const & rhs) const6530     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6531     {
6532       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
6533     }
6534 
operator !=(SamplerYcbcrConversion const & rhs) const6535     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6536     {
6537       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
6538     }
6539 
operator <(SamplerYcbcrConversion const & rhs) const6540     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6541     {
6542       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
6543     }
6544 #endif
6545 
operator VkSamplerYcbcrConversion() const6546     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
6547     {
6548       return m_samplerYcbcrConversion;
6549     }
6550 
operator bool() const6551     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6552     {
6553       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
6554     }
6555 
operator !() const6556     bool operator!() const VULKAN_HPP_NOEXCEPT
6557     {
6558       return m_samplerYcbcrConversion == VK_NULL_HANDLE;
6559     }
6560 
6561   private:
6562     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
6563   };
6564   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) ==
6565                               sizeof( VkSamplerYcbcrConversion ),
6566                             "handle and wrapper have different size!" );
6567   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::value,
6568                             "SamplerYcbcrConversion is not nothrow_move_constructible!" );
6569 
6570   template <>
6571   struct VULKAN_HPP_DEPRECATED(
6572     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSamplerYcbcrConversion>
6573   {
6574     using type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6575   };
6576 
6577   template <>
6578   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
6579   {
6580     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6581   };
6582 
6583   template <>
6584   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6585                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
6586   {
6587     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6588   };
6589 
6590   template <>
6591   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
6592   {
6593     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6594   };
6595   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
6596 
6597   class ShaderModule
6598   {
6599   public:
6600     using CType      = VkShaderModule;
6601     using NativeType = VkShaderModule;
6602 
6603     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6604       VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
6605     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6606       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
6607 
6608   public:
6609     VULKAN_HPP_CONSTEXPR         ShaderModule() = default;
ShaderModule(std::nullptr_t)6610     VULKAN_HPP_CONSTEXPR         ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ShaderModule(VkShaderModule shaderModule)6611     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6612       : m_shaderModule( shaderModule )
6613     {}
6614 
6615 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkShaderModule shaderModule)6616     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6617     {
6618       m_shaderModule = shaderModule;
6619       return *this;
6620     }
6621 #endif
6622 
operator =(std::nullptr_t)6623     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6624     {
6625       m_shaderModule = {};
6626       return *this;
6627     }
6628 
6629 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6630     auto operator<=>( ShaderModule const & ) const = default;
6631 #else
operator ==(ShaderModule const & rhs) const6632     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6633     {
6634       return m_shaderModule == rhs.m_shaderModule;
6635     }
6636 
operator !=(ShaderModule const & rhs) const6637     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6638     {
6639       return m_shaderModule != rhs.m_shaderModule;
6640     }
6641 
operator <(ShaderModule const & rhs) const6642     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6643     {
6644       return m_shaderModule < rhs.m_shaderModule;
6645     }
6646 #endif
6647 
operator VkShaderModule() const6648     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
6649     {
6650       return m_shaderModule;
6651     }
6652 
operator bool() const6653     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6654     {
6655       return m_shaderModule != VK_NULL_HANDLE;
6656     }
6657 
operator !() const6658     bool operator!() const VULKAN_HPP_NOEXCEPT
6659     {
6660       return m_shaderModule == VK_NULL_HANDLE;
6661     }
6662 
6663   private:
6664     VkShaderModule m_shaderModule = {};
6665   };
6666   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ),
6667                             "handle and wrapper have different size!" );
6668   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderModule>::value,
6669                             "ShaderModule is not nothrow_move_constructible!" );
6670 
6671   template <>
6672   struct VULKAN_HPP_DEPRECATED(
6673     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eShaderModule>
6674   {
6675     using type = VULKAN_HPP_NAMESPACE::ShaderModule;
6676   };
6677 
6678   template <>
6679   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
6680   {
6681     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6682   };
6683 
6684   template <>
6685   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6686                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
6687   {
6688     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6689   };
6690 
6691   template <>
6692   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
6693   {
6694     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6695   };
6696 
6697   class ValidationCacheEXT
6698   {
6699   public:
6700     using CType      = VkValidationCacheEXT;
6701     using NativeType = VkValidationCacheEXT;
6702 
6703     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6704       VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
6705     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6706       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
6707 
6708   public:
6709     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT() = default;
ValidationCacheEXT(std::nullptr_t)6710     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)6711     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6712       : m_validationCacheEXT( validationCacheEXT )
6713     {}
6714 
6715 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkValidationCacheEXT validationCacheEXT)6716     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6717     {
6718       m_validationCacheEXT = validationCacheEXT;
6719       return *this;
6720     }
6721 #endif
6722 
operator =(std::nullptr_t)6723     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6724     {
6725       m_validationCacheEXT = {};
6726       return *this;
6727     }
6728 
6729 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6730     auto operator<=>( ValidationCacheEXT const & ) const = default;
6731 #else
operator ==(ValidationCacheEXT const & rhs) const6732     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6733     {
6734       return m_validationCacheEXT == rhs.m_validationCacheEXT;
6735     }
6736 
operator !=(ValidationCacheEXT const & rhs) const6737     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6738     {
6739       return m_validationCacheEXT != rhs.m_validationCacheEXT;
6740     }
6741 
operator <(ValidationCacheEXT const & rhs) const6742     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6743     {
6744       return m_validationCacheEXT < rhs.m_validationCacheEXT;
6745     }
6746 #endif
6747 
operator VkValidationCacheEXT() const6748     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
6749     {
6750       return m_validationCacheEXT;
6751     }
6752 
operator bool() const6753     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6754     {
6755       return m_validationCacheEXT != VK_NULL_HANDLE;
6756     }
6757 
operator !() const6758     bool operator!() const VULKAN_HPP_NOEXCEPT
6759     {
6760       return m_validationCacheEXT == VK_NULL_HANDLE;
6761     }
6762 
6763   private:
6764     VkValidationCacheEXT m_validationCacheEXT = {};
6765   };
6766   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ),
6767                             "handle and wrapper have different size!" );
6768   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::value,
6769                             "ValidationCacheEXT is not nothrow_move_constructible!" );
6770 
6771   template <>
6772   struct VULKAN_HPP_DEPRECATED(
6773     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eValidationCacheEXT>
6774   {
6775     using type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6776   };
6777 
6778   template <>
6779   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
6780   {
6781     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6782   };
6783 
6784   template <>
6785   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6786                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
6787   {
6788     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6789   };
6790 
6791   template <>
6792   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
6793   {
6794     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6795   };
6796 
6797 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6798   class VideoSessionParametersKHR
6799   {
6800   public:
6801     using CType      = VkVideoSessionParametersKHR;
6802     using NativeType = VkVideoSessionParametersKHR;
6803 
6804     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6805       VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
6806     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6807       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6808 
6809   public:
6810     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
VideoSessionParametersKHR(std::nullptr_t)6811     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6812     VULKAN_HPP_TYPESAFE_EXPLICIT
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)6813       VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6814       : m_videoSessionParametersKHR( videoSessionParametersKHR )
6815     {}
6816 
6817 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)6818     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6819     {
6820       m_videoSessionParametersKHR = videoSessionParametersKHR;
6821       return *this;
6822     }
6823 #  endif
6824 
operator =(std::nullptr_t)6825     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6826     {
6827       m_videoSessionParametersKHR = {};
6828       return *this;
6829     }
6830 
6831 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6832     auto operator<=>( VideoSessionParametersKHR const & ) const = default;
6833 #  else
operator ==(VideoSessionParametersKHR const & rhs) const6834     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6835     {
6836       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
6837     }
6838 
operator !=(VideoSessionParametersKHR const & rhs) const6839     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6840     {
6841       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
6842     }
6843 
operator <(VideoSessionParametersKHR const & rhs) const6844     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6845     {
6846       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
6847     }
6848 #  endif
6849 
operator VkVideoSessionParametersKHR() const6850     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
6851     {
6852       return m_videoSessionParametersKHR;
6853     }
6854 
operator bool() const6855     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6856     {
6857       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
6858     }
6859 
operator !() const6860     bool operator!() const VULKAN_HPP_NOEXCEPT
6861     {
6862       return m_videoSessionParametersKHR == VK_NULL_HANDLE;
6863     }
6864 
6865   private:
6866     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
6867   };
6868   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) ==
6869                               sizeof( VkVideoSessionParametersKHR ),
6870                             "handle and wrapper have different size!" );
6871   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::value,
6872                             "VideoSessionParametersKHR is not nothrow_move_constructible!" );
6873 
6874   template <>
6875   struct VULKAN_HPP_DEPRECATED(
6876     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionParametersKHR>
6877   {
6878     using type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6879   };
6880 
6881   template <>
6882   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
6883   {
6884     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6885   };
6886 
6887   template <>
6888   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
6889   {
6890     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6891   };
6892 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
6893 
6894   class Queue
6895   {
6896   public:
6897     using CType      = VkQueue;
6898     using NativeType = VkQueue;
6899 
6900     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6901       VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
6902     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6903       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
6904 
6905   public:
6906     VULKAN_HPP_CONSTEXPR         Queue() = default;
Queue(std::nullptr_t)6907     VULKAN_HPP_CONSTEXPR         Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Queue(VkQueue queue)6908     VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
6909 
6910 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueue queue)6911     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
6912     {
6913       m_queue = queue;
6914       return *this;
6915     }
6916 #endif
6917 
operator =(std::nullptr_t)6918     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6919     {
6920       m_queue = {};
6921       return *this;
6922     }
6923 
6924 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6925     auto operator<=>( Queue const & ) const = default;
6926 #else
operator ==(Queue const & rhs) const6927     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6928     {
6929       return m_queue == rhs.m_queue;
6930     }
6931 
operator !=(Queue const & rhs) const6932     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6933     {
6934       return m_queue != rhs.m_queue;
6935     }
6936 
operator <(Queue const & rhs) const6937     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6938     {
6939       return m_queue < rhs.m_queue;
6940     }
6941 #endif
6942 
6943     //=== VK_VERSION_1_0 ===
6944 
6945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6946     VULKAN_HPP_NODISCARD Result
6947       submit( uint32_t                                 submitCount,
6948               const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
6949               VULKAN_HPP_NAMESPACE::Fence              fence,
6950               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6951 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6953     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6954       submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
6955               VULKAN_HPP_NAMESPACE::Fence fence                          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6956               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6957 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6958 
6959 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6961     VULKAN_HPP_NODISCARD Result
6962       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6963 #else
6964     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6965     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6966       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6967 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6968 
6969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6970     VULKAN_HPP_NODISCARD Result
6971       bindSparse( uint32_t                                     bindInfoCount,
6972                   const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
6973                   VULKAN_HPP_NAMESPACE::Fence                  fence,
6974                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6977     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6978       bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
6979                   VULKAN_HPP_NAMESPACE::Fence fence                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6980                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6981 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6982 
6983     //=== VK_KHR_swapchain ===
6984 
6985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6986     VULKAN_HPP_NODISCARD Result
6987       presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
6988                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6991     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,
6992                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6993 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6994 
6995     //=== VK_EXT_debug_utils ===
6996 
6997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6998     void
6999       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
7000                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7003     void
7004       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
7005                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7006 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7007 
7008     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7009     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7010 
7011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7012     void
7013       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
7014                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7017     void
7018       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
7019                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7020 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7021 
7022     //=== VK_NV_device_diagnostic_checkpoints ===
7023 
7024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7025     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
7026                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
7027                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7028 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7029     template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
7030               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7031     VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
7032                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7033     template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
7034               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7035               typename B                         = CheckpointDataNVAllocator,
7036               typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
7037     VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
7038                          getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator,
7039                                               Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7040 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7041 
7042     //=== VK_INTEL_performance_query ===
7043 
7044 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7046     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL(
7047       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
7048       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7049 #else
7050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7051     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7052          setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
7053                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7054 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7055 
7056     //=== VK_KHR_synchronization2 ===
7057 
7058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7059     VULKAN_HPP_NODISCARD Result
7060       submit2KHR( uint32_t                                     submitCount,
7061                   const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits,
7062                   VULKAN_HPP_NAMESPACE::Fence                  fence,
7063                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7066     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7067       submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
7068                   VULKAN_HPP_NAMESPACE::Fence fence                              VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7069                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7070 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7071 
7072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7073     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
7074                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
7075                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7077     template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
7078               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7079     VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
7080                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7081     template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
7082               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7083               typename B                          = CheckpointData2NVAllocator,
7084               typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type = 0>
7085     VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
7086                          getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator,
7087                                                Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7088 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7089 
operator VkQueue() const7090     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const VULKAN_HPP_NOEXCEPT
7091     {
7092       return m_queue;
7093     }
7094 
operator bool() const7095     explicit operator bool() const VULKAN_HPP_NOEXCEPT
7096     {
7097       return m_queue != VK_NULL_HANDLE;
7098     }
7099 
operator !() const7100     bool operator!() const VULKAN_HPP_NOEXCEPT
7101     {
7102       return m_queue == VK_NULL_HANDLE;
7103     }
7104 
7105   private:
7106     VkQueue m_queue = {};
7107   };
7108   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ),
7109                             "handle and wrapper have different size!" );
7110   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Queue>::value,
7111                             "Queue is not nothrow_move_constructible!" );
7112 
7113   template <>
7114   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueue>
7115   {
7116     using type = VULKAN_HPP_NAMESPACE::Queue;
7117   };
7118 
7119   template <>
7120   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
7121   {
7122     using Type = VULKAN_HPP_NAMESPACE::Queue;
7123   };
7124 
7125   template <>
7126   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
7127   {
7128     using Type = VULKAN_HPP_NAMESPACE::Queue;
7129   };
7130 
7131   template <>
7132   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
7133   {
7134     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7135   };
7136 
7137 #ifndef VULKAN_HPP_NO_SMART_HANDLE
7138   class Device;
7139   template <typename Dispatch>
7140   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
7141   {
7142   public:
7143     using deleter = ObjectDestroy<Device, Dispatch>;
7144   };
7145   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7146   template <typename Dispatch>
7147   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
7148   {
7149   public:
7150     using deleter = ObjectDestroy<Device, Dispatch>;
7151   };
7152   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7153   template <typename Dispatch>
7154   class UniqueHandleTraits<Buffer, Dispatch>
7155   {
7156   public:
7157     using deleter = ObjectDestroy<Device, Dispatch>;
7158   };
7159   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7160 #  if defined( VK_USE_PLATFORM_FUCHSIA )
7161   template <typename Dispatch>
7162   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
7163   {
7164   public:
7165     using deleter = ObjectDestroy<Device, Dispatch>;
7166   };
7167   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7168 #  endif /*VK_USE_PLATFORM_FUCHSIA*/
7169   template <typename Dispatch>
7170   class UniqueHandleTraits<BufferView, Dispatch>
7171   {
7172   public:
7173     using deleter = ObjectDestroy<Device, Dispatch>;
7174   };
7175   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7176   template <typename Dispatch>
7177   class UniqueHandleTraits<CommandBuffer, Dispatch>
7178   {
7179   public:
7180     using deleter = PoolFree<Device, CommandPool, Dispatch>;
7181   };
7182   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7183   template <typename Dispatch>
7184   class UniqueHandleTraits<CommandPool, Dispatch>
7185   {
7186   public:
7187     using deleter = ObjectDestroy<Device, Dispatch>;
7188   };
7189   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7190   template <typename Dispatch>
7191   class UniqueHandleTraits<CuFunctionNVX, Dispatch>
7192   {
7193   public:
7194     using deleter = ObjectDestroy<Device, Dispatch>;
7195   };
7196   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7197   template <typename Dispatch>
7198   class UniqueHandleTraits<CuModuleNVX, Dispatch>
7199   {
7200   public:
7201     using deleter = ObjectDestroy<Device, Dispatch>;
7202   };
7203   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7204   template <typename Dispatch>
7205   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
7206   {
7207   public:
7208     using deleter = ObjectDestroy<Device, Dispatch>;
7209   };
7210   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7211   template <typename Dispatch>
7212   class UniqueHandleTraits<DescriptorPool, Dispatch>
7213   {
7214   public:
7215     using deleter = ObjectDestroy<Device, Dispatch>;
7216   };
7217   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7218   template <typename Dispatch>
7219   class UniqueHandleTraits<DescriptorSet, Dispatch>
7220   {
7221   public:
7222     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
7223   };
7224   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7225   template <typename Dispatch>
7226   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
7227   {
7228   public:
7229     using deleter = ObjectDestroy<Device, Dispatch>;
7230   };
7231   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7232   template <typename Dispatch>
7233   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
7234   {
7235   public:
7236     using deleter = ObjectDestroy<Device, Dispatch>;
7237   };
7238   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7239   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7240   template <typename Dispatch>
7241   class UniqueHandleTraits<DeviceMemory, Dispatch>
7242   {
7243   public:
7244     using deleter = ObjectFree<Device, Dispatch>;
7245   };
7246   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7247   template <typename Dispatch>
7248   class UniqueHandleTraits<Event, Dispatch>
7249   {
7250   public:
7251     using deleter = ObjectDestroy<Device, Dispatch>;
7252   };
7253   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7254   template <typename Dispatch>
7255   class UniqueHandleTraits<Fence, Dispatch>
7256   {
7257   public:
7258     using deleter = ObjectDestroy<Device, Dispatch>;
7259   };
7260   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7261   template <typename Dispatch>
7262   class UniqueHandleTraits<Framebuffer, Dispatch>
7263   {
7264   public:
7265     using deleter = ObjectDestroy<Device, Dispatch>;
7266   };
7267   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7268   template <typename Dispatch>
7269   class UniqueHandleTraits<Image, Dispatch>
7270   {
7271   public:
7272     using deleter = ObjectDestroy<Device, Dispatch>;
7273   };
7274   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7275   template <typename Dispatch>
7276   class UniqueHandleTraits<ImageView, Dispatch>
7277   {
7278   public:
7279     using deleter = ObjectDestroy<Device, Dispatch>;
7280   };
7281   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7282   template <typename Dispatch>
7283   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
7284   {
7285   public:
7286     using deleter = ObjectDestroy<Device, Dispatch>;
7287   };
7288   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7289   template <typename Dispatch>
7290   class UniqueHandleTraits<Pipeline, Dispatch>
7291   {
7292   public:
7293     using deleter = ObjectDestroy<Device, Dispatch>;
7294   };
7295   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7296   template <typename Dispatch>
7297   class UniqueHandleTraits<PipelineCache, Dispatch>
7298   {
7299   public:
7300     using deleter = ObjectDestroy<Device, Dispatch>;
7301   };
7302   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7303   template <typename Dispatch>
7304   class UniqueHandleTraits<PipelineLayout, Dispatch>
7305   {
7306   public:
7307     using deleter = ObjectDestroy<Device, Dispatch>;
7308   };
7309   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7310   template <typename Dispatch>
7311   class UniqueHandleTraits<PrivateDataSlotEXT, Dispatch>
7312   {
7313   public:
7314     using deleter = ObjectDestroy<Device, Dispatch>;
7315   };
7316   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlotEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7317   template <typename Dispatch>
7318   class UniqueHandleTraits<QueryPool, Dispatch>
7319   {
7320   public:
7321     using deleter = ObjectDestroy<Device, Dispatch>;
7322   };
7323   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7324   template <typename Dispatch>
7325   class UniqueHandleTraits<RenderPass, Dispatch>
7326   {
7327   public:
7328     using deleter = ObjectDestroy<Device, Dispatch>;
7329   };
7330   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7331   template <typename Dispatch>
7332   class UniqueHandleTraits<Sampler, Dispatch>
7333   {
7334   public:
7335     using deleter = ObjectDestroy<Device, Dispatch>;
7336   };
7337   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7338   template <typename Dispatch>
7339   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
7340   {
7341   public:
7342     using deleter = ObjectDestroy<Device, Dispatch>;
7343   };
7344   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7345   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7346   template <typename Dispatch>
7347   class UniqueHandleTraits<Semaphore, Dispatch>
7348   {
7349   public:
7350     using deleter = ObjectDestroy<Device, Dispatch>;
7351   };
7352   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7353   template <typename Dispatch>
7354   class UniqueHandleTraits<ShaderModule, Dispatch>
7355   {
7356   public:
7357     using deleter = ObjectDestroy<Device, Dispatch>;
7358   };
7359   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7360   template <typename Dispatch>
7361   class UniqueHandleTraits<SwapchainKHR, Dispatch>
7362   {
7363   public:
7364     using deleter = ObjectDestroy<Device, Dispatch>;
7365   };
7366   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7367   template <typename Dispatch>
7368   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
7369   {
7370   public:
7371     using deleter = ObjectDestroy<Device, Dispatch>;
7372   };
7373   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7374 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
7375   template <typename Dispatch>
7376   class UniqueHandleTraits<VideoSessionKHR, Dispatch>
7377   {
7378   public:
7379     using deleter = ObjectDestroy<Device, Dispatch>;
7380   };
7381   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7382 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
7383 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
7384   template <typename Dispatch>
7385   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
7386   {
7387   public:
7388     using deleter = ObjectDestroy<Device, Dispatch>;
7389   };
7390   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7391 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
7392 #endif   /*VULKAN_HPP_NO_SMART_HANDLE*/
7393 
7394   class Device
7395   {
7396   public:
7397     using CType      = VkDevice;
7398     using NativeType = VkDevice;
7399 
7400     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
7401       VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
7402     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
7403       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
7404 
7405   public:
7406     VULKAN_HPP_CONSTEXPR         Device() = default;
Device(std::nullptr_t)7407     VULKAN_HPP_CONSTEXPR         Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Device(VkDevice device)7408     VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
7409 
7410 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDevice device)7411     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
7412     {
7413       m_device = device;
7414       return *this;
7415     }
7416 #endif
7417 
operator =(std::nullptr_t)7418     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7419     {
7420       m_device = {};
7421       return *this;
7422     }
7423 
7424 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7425     auto operator<=>( Device const & ) const = default;
7426 #else
operator ==(Device const & rhs) const7427     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7428     {
7429       return m_device == rhs.m_device;
7430     }
7431 
operator !=(Device const & rhs) const7432     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7433     {
7434       return m_device != rhs.m_device;
7435     }
7436 
operator <(Device const & rhs) const7437     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7438     {
7439       return m_device < rhs.m_device;
7440     }
7441 #endif
7442 
7443     //=== VK_VERSION_1_0 ===
7444 
7445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7446     PFN_vkVoidFunction
7447       getProcAddr( const char *       pName,
7448                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7449 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7450     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7451     PFN_vkVoidFunction
7452       getProcAddr( const std::string & name,
7453                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7454 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7455 
7456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7457     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7458                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7459 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7461     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7462                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7463                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7464 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7465 
7466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7467     void getQueue( uint32_t                      queueFamilyIndex,
7468                    uint32_t                      queueIndex,
7469                    VULKAN_HPP_NAMESPACE::Queue * pQueue,
7470                    Dispatch const & d            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7473     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
7474                          getQueue( uint32_t           queueFamilyIndex,
7475                                    uint32_t           queueIndex,
7476                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7477 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7478 
7479 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7480     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7481     VULKAN_HPP_NODISCARD Result
7482       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7483 #else
7484     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7485     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7486       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7487 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7488 
7489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7490     VULKAN_HPP_NODISCARD Result
7491       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
7492                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7493                       VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,
7494                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7495 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7497     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
7498       allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo,
7499                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7500                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7501                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7502 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7503     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7504     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7505       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
7506       allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo,
7507                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7508                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7509                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7510 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7511 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7512 
7513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7514     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
7515                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7516                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7519     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7520                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7521                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7522                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7523 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7524 
7525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7526     void free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
7527                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7528                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7529 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7531     void free( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7532                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7533                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7534                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7535 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7536 
7537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7538     VULKAN_HPP_NODISCARD Result
7539       mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
7540                  VULKAN_HPP_NAMESPACE::DeviceSize     offset,
7541                  VULKAN_HPP_NAMESPACE::DeviceSize     size,
7542                  VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
7543                  void **                              ppData,
7544                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7545 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7547     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void *>::type
7548       mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory         memory,
7549                  VULKAN_HPP_NAMESPACE::DeviceSize           offset,
7550                  VULKAN_HPP_NAMESPACE::DeviceSize           size,
7551                  VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7552                  Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7553 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7554 
7555     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7556     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7557                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7558 
7559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7560     VULKAN_HPP_NODISCARD Result
7561       flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
7562                                const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
7563                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7566     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7567       flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
7568                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7569 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7570 
7571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7572     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(
7573       uint32_t                                        memoryRangeCount,
7574       const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
7575       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7578     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7579       invalidateMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
7580                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7581 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7582 
7583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7584     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7585                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
7586                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7589     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
7590                          getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7591                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7592 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7593 
7594 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7595     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7596     VULKAN_HPP_NODISCARD Result
7597       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
7598                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7599                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7600                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7601 #else
7602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7603     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7604       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
7605                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7606                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7607                         Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7608 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7609 
7610 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7611     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7612     VULKAN_HPP_NODISCARD Result
7613       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
7614                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7615                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7616                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7617 #else
7618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7619     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7620       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
7621                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7622                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7623                        Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7624 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7625 
7626     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7627     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
7628                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7629                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7630       VULKAN_HPP_NOEXCEPT;
7631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7632     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7633     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements(
7634       VULKAN_HPP_NAMESPACE::Buffer buffer,
7635       Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7636 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7637 
7638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7639     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
7640                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7641                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7642       VULKAN_HPP_NOEXCEPT;
7643 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7644     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7645     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements(
7646       VULKAN_HPP_NAMESPACE::Image image,
7647       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7648 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7649 
7650     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7651     void getImageSparseMemoryRequirements(
7652       VULKAN_HPP_NAMESPACE::Image                           image,
7653       uint32_t *                                            pSparseMemoryRequirementCount,
7654       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
7655       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7657     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
7658               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7659     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7660                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
7661                                                            Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7662     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
7663               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7664               typename B                                      = SparseImageMemoryRequirementsAllocator,
7665               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
7666                                       int>::type              = 0>
7667     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7668                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
7669                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
7670                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7671 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7672 
7673     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7674     VULKAN_HPP_NODISCARD Result
7675       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
7676                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7677                    VULKAN_HPP_NAMESPACE::Fence *                     pFence,
7678                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7681     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
7682       createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo,
7683                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7684                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7685                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7686 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7687     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7688     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7689       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
7690       createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo,
7691                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7692                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7693                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7694 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7695 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7696 
7697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7698     void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
7699                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7700                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7703     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7704                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7705                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7706                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7707 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7708 
7709     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7710     void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
7711                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7712                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7714     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7715     void destroy( VULKAN_HPP_NAMESPACE::Fence fence,
7716                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7717                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7718                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7719 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7720 
7721     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7722     VULKAN_HPP_NODISCARD Result
7723       resetFences( uint32_t                            fenceCount,
7724                    const VULKAN_HPP_NAMESPACE::Fence * pFences,
7725                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7728     typename ResultValueType<void>::type
7729       resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
7730                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7731 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7732 
7733 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7735     VULKAN_HPP_NODISCARD Result
7736       getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
7737                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7738 #else
7739     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7740     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
7741                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7742 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7743 
7744     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7745     VULKAN_HPP_NODISCARD Result
7746       waitForFences( uint32_t                            fenceCount,
7747                      const VULKAN_HPP_NAMESPACE::Fence * pFences,
7748                      VULKAN_HPP_NAMESPACE::Bool32        waitAll,
7749                      uint64_t                            timeout,
7750                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7753     VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
7754                                                VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
7755                                                uint64_t                                              timeout,
7756                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7757 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7758 
7759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7760     VULKAN_HPP_NODISCARD Result
7761       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
7762                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7763                        VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
7764                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7767     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
7768       createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo,
7769                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7770                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7771                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7772 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7774     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7775       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
7776       createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo,
7777                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7778                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7779                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7780 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7781 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7782 
7783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7784     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
7785                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7786                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7789     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7790                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7791                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7792                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7793 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7794 
7795     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7796     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
7797                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7798                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7801     void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
7802                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7803                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7804                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7805 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7806 
7807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7808     VULKAN_HPP_NODISCARD Result
7809       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
7810                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7811                    VULKAN_HPP_NAMESPACE::Event *                     pEvent,
7812                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7815     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
7816       createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo,
7817                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7818                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7819                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7820 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7822     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7823       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
7824       createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo,
7825                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7826                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7827                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7828 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7829 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7830 
7831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7832     void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
7833                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7834                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7837     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7838                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7839                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7840                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7841 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7842 
7843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7844     void destroy( VULKAN_HPP_NAMESPACE::Event                       event,
7845                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7846                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7849     void destroy( VULKAN_HPP_NAMESPACE::Event event,
7850                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7851                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7852                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7853 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7854 
7855 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7856     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7857     VULKAN_HPP_NODISCARD Result
7858       getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
7859                       Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7860 #else
7861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7862     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
7863                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7864 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7865 
7866 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7868     VULKAN_HPP_NODISCARD Result
7869       setEvent( VULKAN_HPP_NAMESPACE::Event event,
7870                 Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7871 #else
7872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7873     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7874       setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7875 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7876 
7877 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7879     VULKAN_HPP_NODISCARD Result
7880       resetEvent( VULKAN_HPP_NAMESPACE::Event event,
7881                   Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7882 #else
7883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7884     typename ResultValueType<void>::type
7885       resetEvent( VULKAN_HPP_NAMESPACE::Event event,
7886                   Dispatch const & d          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7887 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7888 
7889     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7890     VULKAN_HPP_NODISCARD Result
7891       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
7892                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7893                        VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
7894                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7895 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7897     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
7898       createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo,
7899                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7900                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7901                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7902 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7903     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7904     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7905       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
7906       createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo,
7907                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7908                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7909                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7910 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7911 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7912 
7913     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7914     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
7915                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7916                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7917 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7919     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7920                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7921                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7922                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7923 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7924 
7925     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7926     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
7927                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7928                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7931     void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
7932                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7933                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7934                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7935 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7936 
7937     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7938     VULKAN_HPP_NODISCARD Result
7939       getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7940                            uint32_t                               firstQuery,
7941                            uint32_t                               queryCount,
7942                            size_t                                 dataSize,
7943                            void *                                 pData,
7944                            VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7945                            VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
7946                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7948     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7949     VULKAN_HPP_NODISCARD Result
7950       getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7951                            uint32_t                               firstQuery,
7952                            uint32_t                               queryCount,
7953                            ArrayProxy<T> const &                  data,
7954                            VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7955                            VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
7956                            Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7957     template <typename T,
7958               typename Allocator = std::allocator<T>,
7959               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7960     VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>>
7961                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
7962                                               uint32_t                                     firstQuery,
7963                                               uint32_t                                     queryCount,
7964                                               size_t                                       dataSize,
7965                                               VULKAN_HPP_NAMESPACE::DeviceSize             stride,
7966                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7967                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7968     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7969     VULKAN_HPP_NODISCARD ResultValue<T>
7970                          getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
7971                                              uint32_t                                     firstQuery,
7972                                              uint32_t                                     queryCount,
7973                                              VULKAN_HPP_NAMESPACE::DeviceSize             stride,
7974                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7975                                              Dispatch const & d                           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7976 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7977 
7978     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7979     VULKAN_HPP_NODISCARD Result
7980       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
7981                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7982                     VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,
7983                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7986     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
7987       createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo,
7988                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7989                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7990                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7991 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7993     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7994       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
7995       createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo,
7996                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
7997                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7998                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7999 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8000 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8001 
8002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8003     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
8004                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8005                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8006 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8008     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8009                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8010                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8011                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8012 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8013 
8014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8015     void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
8016                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8017                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8019     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8020     void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer,
8021                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8022                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8023                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8024 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8025 
8026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8027     VULKAN_HPP_NODISCARD Result
8028       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
8029                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
8030                         VULKAN_HPP_NAMESPACE::BufferView *                 pView,
8031                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8032 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8034     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
8035       createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo,
8036                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8037                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8038                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8039 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8041     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8042       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
8043       createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo,
8044                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8045                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8046                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8047 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8048 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8049 
8050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8051     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
8052                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8053                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8056     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8057                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8058                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8059                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8060 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8061 
8062     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8063     void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
8064                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8065                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8066 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8067     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8068     void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
8069                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8070                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8071                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8072 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8073 
8074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8075     VULKAN_HPP_NODISCARD Result
8076       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
8077                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8078                    VULKAN_HPP_NAMESPACE::Image *                     pImage,
8079                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8080 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8081     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8082     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
8083       createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo,
8084                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8085                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8086                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8087 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8089     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8090       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
8091       createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo,
8092                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8093                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8094                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8095 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8096 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8097 
8098     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8099     void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
8100                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8101                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8102 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8103     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8104     void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8105                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8106                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8107                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8108 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8109 
8110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8111     void destroy( VULKAN_HPP_NAMESPACE::Image                       image,
8112                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8113                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8116     void destroy( VULKAN_HPP_NAMESPACE::Image image,
8117                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8118                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8119                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8120 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8121 
8122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8123     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
8124                                     const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
8125                                     VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
8126                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8127       VULKAN_HPP_NOEXCEPT;
8128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8130     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout(
8131       VULKAN_HPP_NAMESPACE::Image                    image,
8132       const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
8133       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8134 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8135 
8136     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8137     VULKAN_HPP_NODISCARD Result
8138       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
8139                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8140                        VULKAN_HPP_NAMESPACE::ImageView *                 pView,
8141                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8143     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8144     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
8145       createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo,
8146                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8147                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8148                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8149 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8150     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8151     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8152       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
8153       createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo,
8154                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8155                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8156                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8157 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8158 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8159 
8160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8161     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
8162                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8163                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8166     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8167                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8168                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8169                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8170 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8171 
8172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8173     void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
8174                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8175                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8178     void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
8179                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8180                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8181                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8182 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8183 
8184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8185     VULKAN_HPP_NODISCARD Result
8186       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
8187                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
8188                           VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
8189                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8190 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8192     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
8193       createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
8194                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8195                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8196                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8197 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8199     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8200       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
8201       createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
8202                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8203                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8204                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8205 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8206 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8207 
8208     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8209     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
8210                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8211                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8214     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8215                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8216                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8217                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8218 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8219 
8220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8221     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
8222                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8223                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8225     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8226     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
8227                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8228                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8229                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8230 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8231 
8232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8233     VULKAN_HPP_NODISCARD Result
8234       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
8235                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
8236                            VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
8237                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8238 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8240     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
8241       createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo,
8242                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8243                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8244                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8245 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8247     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8248       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
8249       createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo,
8250                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8251                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8252                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8253 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8254 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8255 
8256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8257     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
8258                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8259                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8260 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8261     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8262     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8263                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8264                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8265                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8266 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8267 
8268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8269     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
8270                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8271                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8273     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8274     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8275                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8276                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8277                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8278 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8279 
8280     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8281     VULKAN_HPP_NODISCARD Result
8282       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8283                             size_t *                            pDataSize,
8284                             void *                              pData,
8285                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8286 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8287     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
8288               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8289     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
8290       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8291                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8292     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
8293               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8294               typename B                = Uint8_tAllocator,
8295               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
8296     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
8297       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
8298                             Uint8_tAllocator &                  uint8_tAllocator,
8299                             Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8300 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8301 
8302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8303     VULKAN_HPP_NODISCARD Result
8304       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
8305                            uint32_t                                    srcCacheCount,
8306                            const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
8307                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8308 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8309     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8310     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8311       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
8312                            ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
8313                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8314 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8315 
8316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8317     VULKAN_HPP_NODISCARD Result
8318       createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
8319                                uint32_t                                                 createInfoCount,
8320                                const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
8321                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
8322                                VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
8323                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8325     template <typename PipelineAllocator = std::allocator<Pipeline>,
8326               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8327     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8328                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8329                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8330                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8331                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8332                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8333     template <typename PipelineAllocator = std::allocator<Pipeline>,
8334               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8335               typename B                 = PipelineAllocator,
8336               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
8337     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8338                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8339                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8340                                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                  allocator,
8341                                                   PipelineAllocator & pipelineAllocator,
8342                                                   Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8344     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
8345                          createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
8346                                                  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
8347                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8348                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8349                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8350 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8351     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8352               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
8353     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8354                          createGraphicsPipelinesUnique(
8355                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8356                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8357                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8358                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8359                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8360     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8361               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
8362               typename B                         = PipelineAllocator,
8363               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
8364                                       int>::type = 0>
8365     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8366                          createGraphicsPipelinesUnique(
8367                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
8368                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
8369                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                  allocator,
8370                            PipelineAllocator &                                                        pipelineAllocator,
8371                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8372     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8373     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
8374                          createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
8375                                                        const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
8376                                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8377                                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8378                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8379 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8380 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8381 
8382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8383     VULKAN_HPP_NODISCARD Result
8384       createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
8385                               uint32_t                                                createInfoCount,
8386                               const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
8387                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
8388                               VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,
8389                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8390 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8391     template <typename PipelineAllocator = std::allocator<Pipeline>,
8392               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8393     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8394                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8395                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8396                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8397                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8398                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8399     template <typename PipelineAllocator = std::allocator<Pipeline>,
8400               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8401               typename B                 = PipelineAllocator,
8402               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
8403     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
8404                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8405                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8406                                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                 allocator,
8407                                                  PipelineAllocator & pipelineAllocator,
8408                                                  Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8410     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
8411                          createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
8412                                                 const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
8413                                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8414                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8415                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8416 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8417     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8418               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
8419     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8420                          createComputePipelinesUnique(
8421                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8422                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8423                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8424                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8425                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8426     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8427               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
8428               typename B                         = PipelineAllocator,
8429               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
8430                                       int>::type = 0>
8431     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
8432                          createComputePipelinesUnique(
8433                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
8434                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
8435                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                 allocator,
8436                            PipelineAllocator &                                                       pipelineAllocator,
8437                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8439     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
8440                          createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
8441                                                       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
8442                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8443                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8444                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8445 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8446 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8447 
8448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8449     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
8450                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8451                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8452 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8453     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8454     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8455                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8456                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8457                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8458 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8459 
8460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8461     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
8462                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8463                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8464 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8466     void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
8467                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8468                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8469                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8470 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8471 
8472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8473     VULKAN_HPP_NODISCARD Result
8474       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
8475                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
8476                             VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
8477                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8480     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
8481       createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo,
8482                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8483                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8484                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8485 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8487     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8488       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
8489       createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo,
8490                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8491                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8492                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8493 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8494 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8495 
8496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8497     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
8498                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8499                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8502     void
8503       destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8504                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8505                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8506                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8507 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8508 
8509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8510     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
8511                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8512                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8515     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
8516                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8517                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8518                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8519 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8520 
8521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8522     VULKAN_HPP_NODISCARD Result
8523       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
8524                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8525                      VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
8526                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8527 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8528     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8529     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
8530       createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo,
8531                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8532                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8533                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8534 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8535     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8536     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8537       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
8538       createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo,
8539                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8540                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8541                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8542 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8543 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8544 
8545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8546     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
8547                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8548                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8551     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8552                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8553                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8554                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8555 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8556 
8557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8558     void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
8559                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8560                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8561 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8562     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8563     void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler,
8564                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8565                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8566                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8567 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8568 
8569     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8570     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(
8571       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
8572       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
8573       VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
8574       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8575 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8576     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8577     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
8578       createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
8579                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8580                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8581                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8582 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8584     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8585       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
8586       createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
8587                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8588                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8589                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8590 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8591 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8592 
8593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8594     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
8595                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8596                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8597       VULKAN_HPP_NOEXCEPT;
8598 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8599     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8600     void destroyDescriptorSetLayout(
8601       VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8602       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8603                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8604       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8605 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8606 
8607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8608     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
8609                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8610                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8611 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8612     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8613     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
8614                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8615                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8616                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8617 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8618 
8619     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8620     VULKAN_HPP_NODISCARD Result
8621       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
8622                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
8623                             VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,
8624                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8625 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8626     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8627     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
8628       createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo,
8629                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8630                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8631                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8632 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8634     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8635       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
8636       createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo,
8637                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8638                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8639                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8640 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8641 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8642 
8643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8644     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
8645                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8646                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8647 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8649     void
8650       destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8651                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8652                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8653                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8654 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8655 
8656     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8657     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
8658                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8659                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8660 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8661     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8662     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
8663                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8664                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8665                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8666 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8667 
8668 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8670     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
8671                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
8672                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8673 #else
8674     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8675     typename ResultValueType<void>::type
8676       resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool                 descriptorPool,
8677                            VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8678                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8679 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8680 
8681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8682     VULKAN_HPP_NODISCARD Result
8683       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
8684                               VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
8685                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8686 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8687     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
8688               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8689     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8690       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
8691       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8692                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8693     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
8694               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8695               typename B                      = DescriptorSetAllocator,
8696               typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
8697     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8698       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
8699       allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8700                               DescriptorSetAllocator &                                descriptorSetAllocator,
8701                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8702 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8703     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8704               typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
8705     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8706       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
8707       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8708                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8709     template <
8710       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8711       typename DescriptorSetAllocator    = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
8712       typename B                         = DescriptorSetAllocator,
8713       typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
8714                               int>::type = 0>
8715     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8716       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
8717       allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
8718                                     DescriptorSetAllocator &                                descriptorSetAllocator,
8719                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8720 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8721 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8722 
8723     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8724     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
8725                                uint32_t                                    descriptorSetCount,
8726                                const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8727                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8728 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8730     typename ResultValueType<void>::type
8731       freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
8732                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
8733                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8734 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8735 
8736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8737     Result free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
8738                  uint32_t                                    descriptorSetCount,
8739                  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8740                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8741 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8743     typename ResultValueType<void>::type
8744       free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
8745             ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
8746             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8747 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8748 
8749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8750     void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
8751                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
8752                                uint32_t                                         descriptorCopyCount,
8753                                const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
8754                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8755 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8756     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8757     void updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
8758                                ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
8759                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8760 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8761 
8762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8763     VULKAN_HPP_NODISCARD Result
8764       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
8765                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8766                          VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
8767                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8770     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
8771       createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo,
8772                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8773                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8774                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8775 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8776     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8777     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8778       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
8779       createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo,
8780                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8781                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8782                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8783 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8784 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8785 
8786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8787     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
8788                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8789                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8790 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8791     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8792     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8793                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8794                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8795                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8796 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8797 
8798     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8799     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
8800                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8801                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8802 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8804     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
8805                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8806                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8807                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8808 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8809 
8810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8811     VULKAN_HPP_NODISCARD Result
8812       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
8813                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
8814                         VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
8815                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8816 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8818     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
8819       createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo,
8820                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8821                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8822                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8823 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8825     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8826       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
8827       createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo,
8828                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8829                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8830                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8831 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8832 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8833 
8834     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8835     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
8836                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8837                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8838 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8839     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8840     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8841                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8842                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8843                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8844 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8845 
8846     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8847     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
8848                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8849                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8850 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8851     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8852     void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8853                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8854                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8855                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8856 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8857 
8858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8859     void
8860       getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8861                                 VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
8862                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8865     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
8866                          getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8867                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8868 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8869 
8870     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8871     VULKAN_HPP_NODISCARD Result
8872       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
8873                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8874                          VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
8875                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8878     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
8879       createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo,
8880                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8881                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8882                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8883 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8885     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8886       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
8887       createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo,
8888                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8889                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8890                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8891 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8892 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8893 
8894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8895     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8896                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8897                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8900     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8901                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8902                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8903                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8904 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8905 
8906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8907     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8908                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8909                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8911     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8912     void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
8913                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
8914                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8915                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8916 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8917 
8918 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8919     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8920     VULKAN_HPP_NODISCARD Result
8921       resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8922                         VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
8923                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8924 #else
8925     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8926     typename ResultValueType<void>::type
8927       resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8928                         VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8929                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8930 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8931 
8932     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8933     VULKAN_HPP_NODISCARD Result
8934       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
8935                               VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
8936                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8937 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8938     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
8939               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8940     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8941       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
8942       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8943                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8944     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
8945               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8946               typename B                      = CommandBufferAllocator,
8947               typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
8948     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8949       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
8950       allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8951                               CommandBufferAllocator &                                commandBufferAllocator,
8952                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8953 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8954     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8955               typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
8956     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8957       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
8958       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8959                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8960     template <
8961       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8962       typename CommandBufferAllocator    = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
8963       typename B                         = CommandBufferAllocator,
8964       typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
8965                               int>::type = 0>
8966     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8967       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
8968       allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
8969                                     CommandBufferAllocator &                                commandBufferAllocator,
8970                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8971 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8972 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8973 
8974     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8975     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8976                              uint32_t                                    commandBufferCount,
8977                              const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
8978                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8981     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
8982                              ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
8983                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8984 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8985 
8986     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8987     void free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8988                uint32_t                                    commandBufferCount,
8989                const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
8990                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8993     void free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
8994                ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
8995                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8996 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8997 
8998     //=== VK_VERSION_1_1 ===
8999 
9000     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9001     VULKAN_HPP_NODISCARD Result
9002       bindBufferMemory2( uint32_t                                           bindInfoCount,
9003                          const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
9004                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9005 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9007     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9008       bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
9009                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9010 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9011 
9012     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9013     VULKAN_HPP_NODISCARD Result
9014       bindImageMemory2( uint32_t                                          bindInfoCount,
9015                         const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
9016                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9017 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9018     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9019     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9020       bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
9021                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9022 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9023 
9024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9025     void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
9026                                      uint32_t                                       localDeviceIndex,
9027                                      uint32_t                                       remoteDeviceIndex,
9028                                      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
9029                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9030       VULKAN_HPP_NOEXCEPT;
9031 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9032     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9033     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
9034       uint32_t           heapIndex,
9035       uint32_t           localDeviceIndex,
9036       uint32_t           remoteDeviceIndex,
9037       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9038 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9039 
9040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9041     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
9042                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
9043                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9044       VULKAN_HPP_NOEXCEPT;
9045 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9047     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(
9048       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
9049       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9050     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9051     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2(
9052       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
9053       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9054 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9055 
9056     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9057     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
9058                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
9059                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9060       VULKAN_HPP_NOEXCEPT;
9061 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9062     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9063     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(
9064       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
9065       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9066     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9067     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2(
9068       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
9069       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9070 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9071 
9072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9073     void getImageSparseMemoryRequirements2(
9074       const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
9075       uint32_t *                                                       pSparseMemoryRequirementCount,
9076       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
9077       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9079     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
9080               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9081     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9082       getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
9083                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9084     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
9085               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9086               typename B                                       = SparseImageMemoryRequirements2Allocator,
9087               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
9088                                       int>::type               = 0>
9089     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9090                          getImageSparseMemoryRequirements2(
9091                            const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
9092                            SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
9093                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9094 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9095 
9096     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9097     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
9098                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
9099                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9100 
9101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9102     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
9103                     VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
9104                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9107     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
9108                          getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,
9109                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9110 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9111 
9112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9113     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(
9114       const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
9115       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
9116       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
9117       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9118 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9119     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9120     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
9121       createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & 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::SamplerYcbcrConversion, Dispatch>>::type
9129       createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & 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 destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
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 destroySamplerYcbcrConversion(
9144       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion 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::SamplerYcbcrConversion      ycbcrConversion,
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::SamplerYcbcrConversion ycbcrConversion,
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     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(
9164       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
9165       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
9166       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
9167       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9168 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9170     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9171       typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
9172       createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
9173                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9174                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9175                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9176 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9178     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9179       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
9180       createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
9181                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9182                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9183                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9184 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9185 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9186 
9187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9188     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
9189                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9190                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9191       VULKAN_HPP_NOEXCEPT;
9192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9193     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9194     void destroyDescriptorUpdateTemplate(
9195       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9196       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9197                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9198       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9199 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9200 
9201     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9202     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
9203                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9204                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9207     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9208                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9209                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9210                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9211 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9212 
9213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9214     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
9215                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9216                                           const void *                                   pData,
9217                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9218       VULKAN_HPP_NOEXCEPT;
9219 
9220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9221     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
9222                                         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
9223                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9224       VULKAN_HPP_NOEXCEPT;
9225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9227     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
9228       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
9229       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9230     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9231     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(
9232       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
9233       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9234 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9235 
9236     //=== VK_VERSION_1_2 ===
9237 
9238     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9239     VULKAN_HPP_NODISCARD Result
9240       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
9241                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9242                          VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
9243                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9244 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9245     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9246     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
9247       createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
9248                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9249                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9250                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9251 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9252     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9253     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9254       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
9255       createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
9256                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9257                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9258                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9259 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9260 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9261 
9262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9263     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9264                          uint32_t                        firstQuery,
9265                          uint32_t                        queryCount,
9266                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9267 
9268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9269     VULKAN_HPP_NODISCARD Result
9270       getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9271                                 uint64_t *                      pValue,
9272                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9273 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9275     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
9276       getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9277                                 Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9278 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9279 
9280     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9281     VULKAN_HPP_NODISCARD Result
9282       waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
9283                       uint64_t                                        timeout,
9284                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9286     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9287     VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
9288                                                 uint64_t                                        timeout,
9289                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9290 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9291 
9292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9293     VULKAN_HPP_NODISCARD Result
9294       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
9295                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9296 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9297     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9298     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9299       signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo,
9300                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9301 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9302 
9303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9304     DeviceAddress
9305       getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
9306                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9309     DeviceAddress
9310       getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
9311                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9312 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9313 
9314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9315     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
9316                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9317       VULKAN_HPP_NOEXCEPT;
9318 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9320     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
9321                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9322       VULKAN_HPP_NOEXCEPT;
9323 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9324 
9325     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9326     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
9327                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9328       VULKAN_HPP_NOEXCEPT;
9329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9331     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
9332                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9333       VULKAN_HPP_NOEXCEPT;
9334 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9335 
9336     //=== VK_KHR_swapchain ===
9337 
9338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9339     VULKAN_HPP_NODISCARD Result
9340       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
9341                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
9342                           VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
9343                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9344 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9345     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9346     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
9347       createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9348                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9349                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9350                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9351 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9353     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9354       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
9355       createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9356                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9357                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9358                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9359 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9360 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9361 
9362     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9363     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
9364                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9365                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9368     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9369                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9370                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9371                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9372 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9373 
9374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9375     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
9376                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
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     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9381                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9382                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9383                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9384 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9385 
9386     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9387     VULKAN_HPP_NODISCARD Result
9388       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9389                              uint32_t *                         pSwapchainImageCount,
9390                              VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
9391                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9393     template <typename ImageAllocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9394     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
9395       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9396                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9397     template <typename ImageAllocator = std::allocator<Image>,
9398               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9399               typename B              = ImageAllocator,
9400               typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
9401     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
9402       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9403                              ImageAllocator &                   imageAllocator,
9404                              Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9405 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9406 
9407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9408     VULKAN_HPP_NODISCARD Result
9409       acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9410                            uint64_t                           timeout,
9411                            VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
9412                            VULKAN_HPP_NAMESPACE::Fence        fence,
9413                            uint32_t *                         pImageIndex,
9414                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9415 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9416     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9417     VULKAN_HPP_NODISCARD ResultValue<uint32_t>
9418                          acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR        swapchain,
9419                                               uint64_t                                  timeout,
9420                                               VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9421                                               VULKAN_HPP_NAMESPACE::Fence fence         VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9422                                               Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9423 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9424 
9425     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9426     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(
9427       VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
9428       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9431     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9432       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
9433       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9434 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9435 
9436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9437     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(
9438       VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
9439       VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
9440       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9441 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9443     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9444       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
9445       getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
9446                                       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9447 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9448 
9449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9450     VULKAN_HPP_NODISCARD Result
9451       acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
9452                             uint32_t *                                            pImageIndex,
9453                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9456     VULKAN_HPP_NODISCARD ResultValue<uint32_t>
9457                          acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,
9458                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9459 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9460 
9461     //=== VK_KHR_display_swapchain ===
9462 
9463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9464     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(
9465       uint32_t                                             swapchainCount,
9466       const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
9467       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
9468       VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
9469       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9471     template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
9472               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9473     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9474       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
9475       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9476                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9477                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9478                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9479     template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
9480               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9481               typename B                     = SwapchainKHRAllocator,
9482               typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
9483     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9484       typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
9485       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9486                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>              allocator,
9487                                  SwapchainKHRAllocator & swapchainKHRAllocator,
9488                                  Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9490     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
9491       createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
9492                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9493                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9494                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9495 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9496     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9497               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
9498     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9499       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
9500       createSharedSwapchainsKHRUnique(
9501         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9502         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9503                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9504         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9505     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9506               typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
9507               typename B                         = SwapchainKHRAllocator,
9508               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
9509                                       int>::type = 0>
9510     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9511       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
9512       createSharedSwapchainsKHRUnique(
9513         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
9514         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>              allocator,
9515         SwapchainKHRAllocator &                                                swapchainKHRAllocator,
9516         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9518     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
9519       createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & 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     //=== VK_EXT_debug_marker ===
9527 
9528     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9529     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(
9530       const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
9531       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9534     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9535       debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,
9536                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9537 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9538 
9539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9540     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(
9541       const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
9542       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9543 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9544     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9545     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9546       debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,
9547                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9548 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9549 
9550 #if defined( VK_ENABLE_BETA_EXTENSIONS )
9551     //=== VK_KHR_video_queue ===
9552 
9553     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9554     VULKAN_HPP_NODISCARD Result
9555       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
9556                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
9557                              VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
9558                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9559 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9561     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
9562       createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
9563                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9564                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9565                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9566 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
9567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9568     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9569       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
9570       createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
9571                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9572                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9573                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9574 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9575 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9576 
9577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9578     void
9579       destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
9580                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9581                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9582 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9584     void
9585       destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9586                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9587                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9588                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9589 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9590 
9591     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9592     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
9593                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9594                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9595 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9597     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9598                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9599                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9600                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9601 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9602 
9603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9604     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(
9605       VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
9606       uint32_t *                                          pVideoSessionMemoryRequirementsCount,
9607       VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
9608       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9609 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9610     template <typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
9611               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9612     VULKAN_HPP_NODISCARD
9613       typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
9614       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
9615                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9616     template <
9617       typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
9618       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9619       typename B                                    = VideoGetMemoryPropertiesKHRAllocator,
9620       typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type = 0>
9621     VULKAN_HPP_NODISCARD
9622       typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
9623       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
9624                                             VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
9625                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9626 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9627 
9628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9629     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(
9630       VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
9631       uint32_t                                         videoSessionBindMemoryCount,
9632       const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
9633       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9634 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9635     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9636     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR(
9637       VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
9638       ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
9639       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9640 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9641 
9642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9643     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(
9644       const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
9645       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
9646       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
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     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9651       typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
9652       createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
9653                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9654                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9655                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9656 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
9657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9658     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9659       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
9660       createVideoSessionParametersKHRUnique(
9661         const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
9662         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9663                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9664         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9665 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9666 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9667 
9668     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9669     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(
9670       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
9671       const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
9672       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9673 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9674     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9675     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9676       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9677                                        const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
9678                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9679 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9680 
9681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9682     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
9683                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9684                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9685       VULKAN_HPP_NOEXCEPT;
9686 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9687     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9688     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9689                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9690                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9691                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9692       VULKAN_HPP_NOEXCEPT;
9693 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9694 
9695     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9696     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
9697                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9698                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9699 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9701     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9702                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9703                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9704                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9705 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9706 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
9707 
9708     //=== VK_NVX_binary_import ===
9709 
9710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9711     VULKAN_HPP_NODISCARD Result
9712       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
9713                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9714                          VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
9715                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9718     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
9719       createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo,
9720                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9721                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9722                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9723 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9725     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9726       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
9727       createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo,
9728                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9729                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9730                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9731 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9732 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9733 
9734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9735     VULKAN_HPP_NODISCARD Result
9736       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
9737                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
9738                            VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
9739                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9740 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9742     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
9743       createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo,
9744                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9745                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9746                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9747 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9749     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9750       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
9751       createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo,
9752                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9753                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9754                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9755 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9756 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9757 
9758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9759     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
9760                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9761                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9764     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
9765                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9766                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9767                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9768 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9769 
9770     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9771     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
9772                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9773                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9776     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
9777                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9778                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9779                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9780 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9781 
9782     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9783     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
9784                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9785                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9787     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9788     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
9789                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9790                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9791                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9792 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9793 
9794     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9795     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
9796                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9797                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9798 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9800     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
9801                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
9802                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9803                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9804 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9805 
9806     //=== VK_NVX_image_view_handle ===
9807 
9808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9809     uint32_t
9810       getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
9811                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9814     uint32_t
9815       getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
9816                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9817 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9818 
9819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9820     VULKAN_HPP_NODISCARD Result
9821       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
9822                               VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
9823                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9825     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9826     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9827       typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
9828       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
9829                               Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9830 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9831 
9832     //=== VK_AMD_shader_info ===
9833 
9834     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9835     VULKAN_HPP_NODISCARD Result
9836       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9837                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9838                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9839                         size_t *                                  pInfoSize,
9840                         void *                                    pInfo,
9841                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9843     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9844               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9845     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9846       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9847                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9848                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9849                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9850     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9851               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9852               typename B                = Uint8_tAllocator,
9853               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
9854     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9855       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9856                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9857                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9858                         Uint8_tAllocator &                        uint8_tAllocator,
9859                         Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9860 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9861 
9862 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9863     //=== VK_NV_external_memory_win32 ===
9864 
9865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9866     VULKAN_HPP_NODISCARD Result
9867       getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
9868                               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
9869                               HANDLE *                                              pHandle,
9870                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9871 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9873     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9874       getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
9875                               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
9876                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9877 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9878 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9879 
9880     //=== VK_KHR_device_group ===
9881 
9882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9883     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
9884                                         uint32_t                                       localDeviceIndex,
9885                                         uint32_t                                       remoteDeviceIndex,
9886                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
9887                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9888       VULKAN_HPP_NOEXCEPT;
9889 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9890     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9891     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
9892       uint32_t           heapIndex,
9893       uint32_t           localDeviceIndex,
9894       uint32_t           remoteDeviceIndex,
9895       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9896 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9897 
9898     //=== VK_KHR_maintenance1 ===
9899 
9900     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9901     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
9902                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
9903                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9904 
9905 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9906     //=== VK_KHR_external_memory_win32 ===
9907 
9908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9909     VULKAN_HPP_NODISCARD Result
9910       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9911                                HANDLE *                                                  pHandle,
9912                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9913 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9915     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9916       getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
9917                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9918 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9919 
9920     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9921     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR(
9922       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9923       HANDLE                                                 handle,
9924       VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
9925       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9926 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9928     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9929       typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
9930       getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9931                                          HANDLE                                                 handle,
9932                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9933 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9934 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9935 
9936     //=== VK_KHR_external_memory_fd ===
9937 
9938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9939     VULKAN_HPP_NODISCARD Result
9940       getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
9941                       int *                                            pFd,
9942                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9945     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
9946       getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,
9947                       Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9948 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9949 
9950     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9951     VULKAN_HPP_NODISCARD Result
9952       getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9953                                 int                                                    fd,
9954                                 VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
9955                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9956 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9957     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9958     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
9959       getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9960                                 int                                                    fd,
9961                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9962 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9963 
9964 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9965     //=== VK_KHR_external_semaphore_win32 ===
9966 
9967     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9968     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR(
9969       const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
9970       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9971 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9972     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9973     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreWin32HandleKHR(
9974       const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
9975       Dispatch const & d                                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9976 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9977 
9978     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9979     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR(
9980       const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9981       HANDLE *                                                     pHandle,
9982       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9983 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9985     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9986       getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
9987                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9988 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9989 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9990 
9991     //=== VK_KHR_external_semaphore_fd ===
9992 
9993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9994     VULKAN_HPP_NODISCARD Result
9995       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
9996                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9998     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9999     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10000       importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
10001                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10002 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10003 
10004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10005     VULKAN_HPP_NODISCARD Result
10006       getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
10007                          int *                                               pFd,
10008                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10009 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10011     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
10012       getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,
10013                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10014 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10015 
10016     //=== VK_KHR_descriptor_update_template ===
10017 
10018     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10019     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(
10020       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
10021       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
10022       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
10023       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10024 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10026     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10027       typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
10028       createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
10029                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10030                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10031                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10032 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10034     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10035       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
10036       createDescriptorUpdateTemplateKHRUnique(
10037         const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
10038         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10039                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10040         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10041 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10042 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10043 
10044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10045     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
10046                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10047                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10048       VULKAN_HPP_NOEXCEPT;
10049 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10051     void destroyDescriptorUpdateTemplateKHR(
10052       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10053       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10054                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10055       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10056 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10057 
10058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10059     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
10060                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10061                                              const void *                                   pData,
10062                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10063       VULKAN_HPP_NOEXCEPT;
10064 
10065     //=== VK_EXT_display_control ===
10066 
10067     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10068     VULKAN_HPP_NODISCARD Result
10069       displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10070                               const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
10071                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10072 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10074     typename ResultValueType<void>::type
10075       displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10076                               const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
10077                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10078 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10079 
10080     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10081     VULKAN_HPP_NODISCARD Result
10082       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
10083                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10084                         VULKAN_HPP_NAMESPACE::Fence *                     pFence,
10085                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10087     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10088     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
10089       registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo,
10090                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10091                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10092                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10093 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10095     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
10096       registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo,
10097                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10098                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10099                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10100 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10101 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10102 
10103     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10104     VULKAN_HPP_NODISCARD Result
10105       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10106                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
10107                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10108                                VULKAN_HPP_NAMESPACE::Fence *                     pFence,
10109                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10112     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
10113       registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10114                                const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
10115                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10116                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10117                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10118 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10119     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10120     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
10121       registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
10122                                      const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
10123                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10124                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10125                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10126 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10127 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10128 
10129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10130     VULKAN_HPP_NODISCARD Result
10131       getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
10132                               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
10133                               uint64_t *                                      pCounterValue,
10134                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10135 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10136     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10137     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
10138       getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
10139                               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
10140                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10141 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10142 
10143     //=== VK_GOOGLE_display_timing ===
10144 
10145     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10146     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(
10147       VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
10148       VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
10149       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10150 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10151     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10152     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10153       typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
10154       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10155                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10156 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10157 
10158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10159     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(
10160       VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
10161       uint32_t *                                           pPresentationTimingCount,
10162       VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
10163       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10164 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10165     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
10166               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10167     VULKAN_HPP_NODISCARD
10168       typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
10169       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10170                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10171     template <
10172       typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
10173       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10174       typename B                                     = PastPresentationTimingGOOGLEAllocator,
10175       typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
10176     VULKAN_HPP_NODISCARD
10177       typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
10178       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
10179                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
10180                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10181 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10182 
10183     //=== VK_EXT_hdr_metadata ===
10184 
10185     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10186     void setHdrMetadataEXT( uint32_t                                     swapchainCount,
10187                             const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
10188                             const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
10189                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10190 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10192     void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
10193                             ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
10194                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10195       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
10196 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10197 
10198     //=== VK_KHR_create_renderpass2 ===
10199 
10200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10201     VULKAN_HPP_NODISCARD Result
10202       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
10203                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
10204                             VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
10205                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10206 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10207     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10208     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
10209       createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
10210                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10211                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10212                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10213 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10215     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10216       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
10217       createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
10218                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10219                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10220                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10221 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10222 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10223 
10224     //=== VK_KHR_shared_presentable_image ===
10225 
10226 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10227     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10228     VULKAN_HPP_NODISCARD Result
10229       getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10230                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10231 #else
10232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10233     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(
10234       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10235 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10236 
10237 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10238     //=== VK_KHR_external_fence_win32 ===
10239 
10240     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10241     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR(
10242       const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
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       importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
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     VULKAN_HPP_NODISCARD Result
10253       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
10254                               HANDLE *                                                 pHandle,
10255                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10256 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10258     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
10259       getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
10260                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10261 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10262 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
10263 
10264     //=== VK_KHR_external_fence_fd ===
10265 
10266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10267     VULKAN_HPP_NODISCARD Result
10268       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
10269                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10272     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10273       importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,
10274                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10275 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10276 
10277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10278     VULKAN_HPP_NODISCARD Result
10279       getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
10280                      int *                                           pFd,
10281                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10282 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10284     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
10285       getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,
10286                      Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10287 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10288 
10289     //=== VK_KHR_performance_query ===
10290 
10291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10292     VULKAN_HPP_NODISCARD Result
10293       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
10294                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10297     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10298       acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,
10299                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10300 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10301 
10302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10303     void
10304       releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10305 
10306     //=== VK_EXT_debug_utils ===
10307 
10308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10309     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
10310       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
10311       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10312 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10314     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10315       setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,
10316                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10317 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10318 
10319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10320     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(
10321       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
10322       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10323 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10324     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10325     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10326       setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,
10327                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10328 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10329 
10330 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
10331     //=== VK_ANDROID_external_memory_android_hardware_buffer ===
10332 
10333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10334     VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID(
10335       const struct AHardwareBuffer *                                 buffer,
10336       VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
10337       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10338 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10340     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10341       typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
10342       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
10343                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10344     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10345     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
10346       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
10347                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10348 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10349 
10350     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10351     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID(
10352       const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
10353       struct AHardwareBuffer **                                               pBuffer,
10354       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10355 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10356     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10357     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<struct AHardwareBuffer *>::type
10358       getMemoryAndroidHardwareBufferANDROID(
10359         const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
10360         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10361 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10362 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
10363 
10364     //=== VK_KHR_get_memory_requirements2 ===
10365 
10366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10367     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
10368                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
10369                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10370       VULKAN_HPP_NOEXCEPT;
10371 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10372     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10373     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(
10374       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10375       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10376     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10377     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(
10378       const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10379       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10380 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10381 
10382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10383     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
10384                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10385                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10386       VULKAN_HPP_NOEXCEPT;
10387 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10389     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(
10390       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10391       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10392     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10393     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(
10394       const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10395       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10396 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10397 
10398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10399     void getImageSparseMemoryRequirements2KHR(
10400       const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
10401       uint32_t *                                                       pSparseMemoryRequirementCount,
10402       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
10403       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10404 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10405     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
10406               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10407     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10408       getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10409                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10410     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
10411               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10412               typename B                                       = SparseImageMemoryRequirements2Allocator,
10413               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
10414                                       int>::type               = 0>
10415     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10416                          getImageSparseMemoryRequirements2KHR(
10417                            const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10418                            SparseImageMemoryRequirements2Allocator &                        sparseImageMemoryRequirements2Allocator,
10419                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10420 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10421 
10422     //=== VK_KHR_acceleration_structure ===
10423 
10424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10425     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(
10426       const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
10427       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
10428       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
10429       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10430 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10432     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10433       typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
10434       createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo,
10435                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10436                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10437                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10438 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10440     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10441       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
10442       createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo,
10443                                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10444                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10445                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10446 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10447 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10448 
10449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10450     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
10451                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10452                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10453       VULKAN_HPP_NOEXCEPT;
10454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10456     void destroyAccelerationStructureKHR(
10457       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10458       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10459                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10460       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10461 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10462 
10463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10464     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
10465                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10466                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10469     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
10470                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10471                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10472                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10473 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10474 
10475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10476     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(
10477       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
10478       uint32_t                                                                     infoCount,
10479       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
10480       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
10481       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10482 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10484     Result buildAccelerationStructuresKHR(
10485       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
10486       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
10487       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
10488       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
10489 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10490 
10491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10492     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(
10493       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
10494       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
10495       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10498     VULKAN_HPP_NODISCARD Result
10499       copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
10500                                     const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
10501                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10502 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10503 
10504     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10505     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(
10506       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
10507       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
10508       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10510     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10511     VULKAN_HPP_NODISCARD Result
10512       copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
10513                                             const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
10514                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10515 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10516 
10517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10518     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(
10519       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
10520       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
10521       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10523     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10524     VULKAN_HPP_NODISCARD Result
10525       copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
10526                                             const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
10527                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10528 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10529 
10530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10531     VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(
10532       uint32_t                                               accelerationStructureCount,
10533       const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
10534       VULKAN_HPP_NAMESPACE::QueryType                        queryType,
10535       size_t                                                 dataSize,
10536       void *                                                 pData,
10537       size_t                                                 stride,
10538       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10539 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10540     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10541     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10542       writeAccelerationStructuresPropertiesKHR(
10543         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
10544         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
10545         ArrayProxy<T> const &                                                    data,
10546         size_t                                                                   stride,
10547         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10548     template <typename T,
10549               typename Allocator = std::allocator<T>,
10550               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10551     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10552       writeAccelerationStructuresPropertiesKHR(
10553         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
10554         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
10555         size_t                                                                   dataSize,
10556         size_t                                                                   stride,
10557         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10558     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10559     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR(
10560       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
10561       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
10562       size_t                                                                   stride,
10563       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10564 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10565 
10566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10567     DeviceAddress getAccelerationStructureAddressKHR(
10568       const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
10569       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10570 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10572     DeviceAddress getAccelerationStructureAddressKHR(
10573       const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,
10574       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10575 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10576 
10577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10578     void getAccelerationStructureCompatibilityKHR(
10579       const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
10580       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
10581       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10584     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
10585                          getAccelerationStructureCompatibilityKHR(
10586                            const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,
10587                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10588 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10589 
10590     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10591     void getAccelerationStructureBuildSizesKHR(
10592       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
10593       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
10594       const uint32_t *                                                        pMaxPrimitiveCounts,
10595       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
10596       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10597 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10599     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
10600                          getAccelerationStructureBuildSizesKHR(
10601                            VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
10602                            const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,
10603                            ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10604                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
10605 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10606 
10607     //=== VK_KHR_sampler_ycbcr_conversion ===
10608 
10609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10610     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(
10611       const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
10612       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
10613       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
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<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
10618       createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
10619                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10620                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10621                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10622 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10624     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10625       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
10626       createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
10627                                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10628                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10629                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10630 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10631 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10632 
10633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10634     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
10635                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10636                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10637       VULKAN_HPP_NOEXCEPT;
10638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10640     void destroySamplerYcbcrConversionKHR(
10641       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10642       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10643                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10644       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10645 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10646 
10647     //=== VK_KHR_bind_memory2 ===
10648 
10649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10650     VULKAN_HPP_NODISCARD Result
10651       bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
10652                             const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
10653                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10654 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10655     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10656     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10657       bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
10658                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10659 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10660 
10661     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10662     VULKAN_HPP_NODISCARD Result
10663       bindImageMemory2KHR( uint32_t                                          bindInfoCount,
10664                            const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
10665                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10667     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10668     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10669       bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
10670                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10671 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10672 
10673     //=== VK_EXT_image_drm_format_modifier ===
10674 
10675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10676     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(
10677       VULKAN_HPP_NAMESPACE::Image                                 image,
10678       VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
10679       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10682     typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
10683       getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image,
10684                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10685 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10686 
10687     //=== VK_EXT_validation_cache ===
10688 
10689     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10690     VULKAN_HPP_NODISCARD Result
10691       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
10692                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
10693                                 VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
10694                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10696     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10697     typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type
10698       createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo,
10699                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10700                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10701                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10702 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10703     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10704     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
10705       createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo,
10706                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10707                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10708                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10709 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10710 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10711 
10712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10713     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
10714                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10715                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10716       VULKAN_HPP_NOEXCEPT;
10717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10719     void destroyValidationCacheEXT(
10720       VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10721       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10722                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10723       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10724 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10725 
10726     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10727     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
10728                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10729                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10731     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10732     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10733                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10734                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10735                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10736 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10737 
10738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10739     VULKAN_HPP_NODISCARD Result
10740       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
10741                                 uint32_t                                         srcCacheCount,
10742                                 const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
10743                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10745     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10746     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10747       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
10748                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
10749                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10750 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10751 
10752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10753     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(
10754       VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10755       size_t *                                 pDataSize,
10756       void *                                   pData,
10757       Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10759     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10760               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10761     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10762       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10763                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10764     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10765               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10766               typename B                = Uint8_tAllocator,
10767               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
10768     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10769       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10770                                  Uint8_tAllocator &                       uint8_tAllocator,
10771                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10772 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10773 
10774     //=== VK_NV_ray_tracing ===
10775 
10776     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10777     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
10778       const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
10779       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
10780       VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
10781       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10784     typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type
10785       createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo,
10786                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10787                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10788                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10789 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10791     VULKAN_HPP_INLINE
10792       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
10793       createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo,
10794                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10795                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10796                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10797 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10798 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10799 
10800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10801     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
10802                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10803                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10804       VULKAN_HPP_NOEXCEPT;
10805 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10806     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10807     void destroyAccelerationStructureNV(
10808       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10809       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10810                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10811       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10812 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10813 
10814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10815     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
10816                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10817                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10818 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10820     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10821                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10822                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10823                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10824 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10825 
10826     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10827     void getAccelerationStructureMemoryRequirementsNV(
10828       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
10829       VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
10830       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10831 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10833     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
10834       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
10835       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10836     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10837     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
10838       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
10839       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10840 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10841 
10842     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10843     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(
10844       uint32_t                                                            bindInfoCount,
10845       const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
10846       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10849     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV(
10850       ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
10851       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10852 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10853 
10854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10855     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(
10856       VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10857       uint32_t                                                     createInfoCount,
10858       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
10859       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
10860       VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
10861       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10862 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10863     template <typename PipelineAllocator = std::allocator<Pipeline>,
10864               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10865     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10866                          createRayTracingPipelinesNV(
10867                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10868                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10869                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10870                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10871                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10872     template <typename PipelineAllocator = std::allocator<Pipeline>,
10873               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10874               typename B                 = PipelineAllocator,
10875               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
10876     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
10877                          createRayTracingPipelinesNV(
10878                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10879                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10880                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                      allocator,
10881                            PipelineAllocator &                                                            pipelineAllocator,
10882                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10884     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
10885                          createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10886                                                      const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
10887                                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10888                                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10889                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10890 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10891     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10892               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
10893     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10894                          createRayTracingPipelinesNVUnique(
10895                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10896                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10897                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10898                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10899                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10900     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10901               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
10902               typename B                         = PipelineAllocator,
10903               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
10904                                       int>::type = 0>
10905     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10906                          createRayTracingPipelinesNVUnique(
10907                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10908                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10909                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                      allocator,
10910                            PipelineAllocator &                                                            pipelineAllocator,
10911                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10913     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
10914                          createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10915                                                            const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
10916                                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
10917                                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10918                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10919 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10920 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10921 
10922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10923     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(
10924       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10925       uint32_t                       firstGroup,
10926       uint32_t                       groupCount,
10927       size_t                         dataSize,
10928       void *                         pData,
10929       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10930 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10931     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10932     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10933       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10934                                          uint32_t                       firstGroup,
10935                                          uint32_t                       groupCount,
10936                                          ArrayProxy<T> const &          data,
10937                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10938     template <typename T,
10939               typename Allocator = std::allocator<T>,
10940               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10941     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10942       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10943                                          uint32_t                       firstGroup,
10944                                          uint32_t                       groupCount,
10945                                          size_t                         dataSize,
10946                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10947     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10948     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10949       getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10950                                         uint32_t                       firstGroup,
10951                                         uint32_t                       groupCount,
10952                                         Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10953 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10954 
10955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10956     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(
10957       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10958       size_t                                        dataSize,
10959       void *                                        pData,
10960       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10961 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10962     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10963     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10964       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10965                                         ArrayProxy<T> const &                         data,
10966                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10967     template <typename T,
10968               typename Allocator = std::allocator<T>,
10969               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10970     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10971       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10972                                         size_t                                        dataSize,
10973                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10974     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10975     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10976       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10977                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10978 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10979 
10980 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10982     VULKAN_HPP_NODISCARD Result
10983       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10984                          uint32_t                       shader,
10985                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10986 #else
10987     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10988     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10989       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10990                          uint32_t                       shader,
10991                          Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10992 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10993 
10994     //=== VK_KHR_maintenance3 ===
10995 
10996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10997     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
10998                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
10999                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11000       VULKAN_HPP_NOEXCEPT;
11001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11003     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
11004       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
11005       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11006     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11007     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(
11008       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
11009       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11010 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11011 
11012     //=== VK_EXT_external_memory_host ===
11013 
11014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11015     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(
11016       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11017       const void *                                           pHostPointer,
11018       VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
11019       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11020 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11022     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11023       typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
11024       getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11025                                          const void *                                           pHostPointer,
11026                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11027 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11028 
11029     //=== VK_EXT_calibrated_timestamps ===
11030 
11031     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11032     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(
11033       uint32_t                                                 timestampCount,
11034       const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
11035       uint64_t *                                               pTimestamps,
11036       uint64_t *                                               pMaxDeviation,
11037       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11040     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
11041       ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
11042       ArrayProxy<uint64_t> const &                                               timestamps,
11043       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11044     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
11045               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11046     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11047       typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
11048       getCalibratedTimestampsEXT(
11049         ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
11050         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11051     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
11052               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11053               typename B                 = Uint64_tAllocator,
11054               typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type = 0>
11055     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11056       typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
11057       getCalibratedTimestampsEXT(
11058         ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
11059         Uint64_tAllocator &                                                        uint64_tAllocator,
11060         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11062     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
11063       getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo,
11064                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11065 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11066 
11067     //=== VK_KHR_timeline_semaphore ===
11068 
11069     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11070     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(
11071       VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11072       uint64_t *                      pValue,
11073       Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11074 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11075     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11076     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
11077       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
11078                                    Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11079 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11080 
11081     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11082     VULKAN_HPP_NODISCARD Result
11083       waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
11084                          uint64_t                                        timeout,
11085                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11087     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11088     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
11089                                                    uint64_t                                        timeout,
11090                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11091 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11092 
11093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11094     VULKAN_HPP_NODISCARD Result
11095       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
11096                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11097 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11098     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11099     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11100       signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo,
11101                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11102 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11103 
11104     //=== VK_INTEL_performance_query ===
11105 
11106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11107     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(
11108       const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
11109       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11111     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11112     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11113       initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,
11114                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11115 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11116 
11117     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11118     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11119       VULKAN_HPP_NOEXCEPT;
11120 
11121     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11122     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(
11123       const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
11124       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
11125       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11126 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11127     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11128     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11129       typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
11130       acquirePerformanceConfigurationINTEL(
11131         const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
11132         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11133 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11135     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11136       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
11137       acquirePerformanceConfigurationINTELUnique(
11138         const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
11139         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11140 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11141 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11142 
11143 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11144     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11145     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(
11146       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
11147       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11148 #else
11149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11150     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL(
11151       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11152       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11153 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11154 
11155 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11157     VULKAN_HPP_NODISCARD Result
11158       release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
11159                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11160 #else
11161     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11162     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11163       release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
11164                Dispatch const & d                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11165 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11166 
11167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11168     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(
11169       VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
11170       VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
11171       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11173     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11174     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
11175       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
11176                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11177 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11178 
11179     //=== VK_AMD_display_native_hdr ===
11180 
11181     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11182     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
11183                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
11184                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11185 
11186     //=== VK_EXT_buffer_device_address ===
11187 
11188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11189     DeviceAddress
11190       getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11191                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11193     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11194     DeviceAddress
11195       getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11196                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11197 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11198 
11199     //=== VK_KHR_present_wait ===
11200 
11201 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11202     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11203     VULKAN_HPP_NODISCARD Result
11204       waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11205                          uint64_t                           presentId,
11206                          uint64_t                           timeout,
11207                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11208 #else
11209     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11210     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11211                                                    uint64_t                           presentId,
11212                                                    uint64_t                           timeout,
11213                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11214 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11215 
11216 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11217     //=== VK_EXT_full_screen_exclusive ===
11218 
11219 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11221     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(
11222       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11223       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11224 #  else
11225     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11226     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11227       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11228                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11229 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11230 
11231 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11233     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(
11234       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11235       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11236 #  else
11237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11238     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11239       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11240                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11241 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11242 
11243     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11244     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT(
11245       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
11246       VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
11247       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11248 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11250     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11251       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
11252       getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
11253                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11254 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11255 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
11256 
11257     //=== VK_KHR_buffer_device_address ===
11258 
11259     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11260     DeviceAddress
11261       getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11262                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11264     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11265     DeviceAddress
11266       getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11267                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11268 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11269 
11270     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11271     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
11272                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11273       VULKAN_HPP_NOEXCEPT;
11274 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11275     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11276     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
11277                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11278       VULKAN_HPP_NOEXCEPT;
11279 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11280 
11281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11282     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
11283                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11284       VULKAN_HPP_NOEXCEPT;
11285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11286     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11287     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
11288                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11289       VULKAN_HPP_NOEXCEPT;
11290 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11291 
11292     //=== VK_EXT_host_query_reset ===
11293 
11294     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11295     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
11296                             uint32_t                        firstQuery,
11297                             uint32_t                        queryCount,
11298                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11299 
11300     //=== VK_KHR_deferred_host_operations ===
11301 
11302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11303     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
11304       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11305       VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
11306       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11309     typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type
11310       createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11311                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11312                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11313 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11314     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11315     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
11316       createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11317                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11318                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11319 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11320 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11321 
11322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11323     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
11324                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11325                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11326       VULKAN_HPP_NOEXCEPT;
11327 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11329     void destroyDeferredOperationKHR(
11330       VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11331       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11332                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11333       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11334 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11335 
11336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11337     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
11338                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11339                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11341     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11342     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11343                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11344                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11345                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11346 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11347 
11348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11349     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11350                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11351       VULKAN_HPP_NOEXCEPT;
11352 
11353 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11354     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11355     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(
11356       VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11357       Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11358 #else
11359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11360     VULKAN_HPP_NODISCARD Result
11361       getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11362                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11363 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11364 
11365 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11367     VULKAN_HPP_NODISCARD Result
11368       deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11369                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11370 #else
11371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11372     VULKAN_HPP_NODISCARD Result
11373       deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
11374                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11375 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11376 
11377     //=== VK_KHR_pipeline_executable_properties ===
11378 
11379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11380     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(
11381       const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
11382       uint32_t *                                              pExecutableCount,
11383       VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
11384       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11385 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11386     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
11387               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11388     VULKAN_HPP_NODISCARD typename ResultValueType<
11389       std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
11390       getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
11391                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11392     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
11393               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11394               typename B                                        = PipelineExecutablePropertiesKHRAllocator,
11395               typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
11396                                       int>::type                = 0>
11397     VULKAN_HPP_NODISCARD typename ResultValueType<
11398       std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
11399       getPipelineExecutablePropertiesKHR(
11400         const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
11401         PipelineExecutablePropertiesKHRAllocator &    pipelineExecutablePropertiesKHRAllocator,
11402         Dispatch const & d                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11403 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11404 
11405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11406     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(
11407       const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
11408       uint32_t *                                              pStatisticCount,
11409       VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
11410       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11411 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11412     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
11413               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11414     VULKAN_HPP_NODISCARD typename ResultValueType<
11415       std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
11416       getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11417                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11418     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
11419               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11420               typename B                                       = PipelineExecutableStatisticKHRAllocator,
11421               typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
11422                                       int>::type               = 0>
11423     VULKAN_HPP_NODISCARD typename ResultValueType<
11424       std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
11425       getPipelineExecutableStatisticsKHR(
11426         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11427         PipelineExecutableStatisticKHRAllocator &               pipelineExecutableStatisticKHRAllocator,
11428         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11429 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11430 
11431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11432     VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(
11433       const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
11434       uint32_t *                                                          pInternalRepresentationCount,
11435       VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
11436       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11438     template <typename PipelineExecutableInternalRepresentationKHRAllocator =
11439                 std::allocator<PipelineExecutableInternalRepresentationKHR>,
11440               typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11441     VULKAN_HPP_NODISCARD
11442       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
11443                                            PipelineExecutableInternalRepresentationKHRAllocator>>::type
11444       getPipelineExecutableInternalRepresentationsKHR(
11445         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11446         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11447     template <
11448       typename PipelineExecutableInternalRepresentationKHRAllocator =
11449         std::allocator<PipelineExecutableInternalRepresentationKHR>,
11450       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11451       typename B                         = PipelineExecutableInternalRepresentationKHRAllocator,
11452       typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
11453                               int>::type = 0>
11454     VULKAN_HPP_NODISCARD
11455       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
11456                                            PipelineExecutableInternalRepresentationKHRAllocator>>::type
11457       getPipelineExecutableInternalRepresentationsKHR(
11458         const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
11459         PipelineExecutableInternalRepresentationKHRAllocator &  pipelineExecutableInternalRepresentationKHRAllocator,
11460         Dispatch const & d                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11461 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11462 
11463     //=== VK_NV_device_generated_commands ===
11464 
11465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11466     void getGeneratedCommandsMemoryRequirementsNV(
11467       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
11468       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
11469       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11471     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11472     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
11473       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
11474       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11475     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11476     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
11477       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
11478       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11479 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11480 
11481     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11482     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(
11483       const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
11484       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
11485       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,
11486       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11489     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11490       typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
11491       createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo,
11492                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11493                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11494                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11495 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11497     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11498       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
11499       createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & 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 destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
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 destroyIndirectCommandsLayoutNV(
11514       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout 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::IndirectCommandsLayoutNV    indirectCommandsLayout,
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::IndirectCommandsLayoutNV indirectCommandsLayout,
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     //=== VK_EXT_private_data ===
11533 
11534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11535     VULKAN_HPP_NODISCARD Result
11536       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo,
11537                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
11538                                 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT *                 pPrivateDataSlot,
11539                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11542     typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::type
11543       createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT & createInfo,
11544                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11545                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11546                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11547 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11549     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type
11550       createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT & createInfo,
11551                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11552                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11553                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11554 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11555 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11556 
11557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11558     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
11559                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11560                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11561       VULKAN_HPP_NOEXCEPT;
11562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11563     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11564     void destroyPrivateDataSlotEXT(
11565       VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11566       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11567                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11568       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11569 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11570 
11571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11572     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
11573                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11574                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11575 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11576     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11577     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11578                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11579                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11580                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11581 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11582 
11583 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11585     VULKAN_HPP_NODISCARD Result
11586       setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11587                          uint64_t                                 objectHandle,
11588                          VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11589                          uint64_t                                 data,
11590                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11591 #else
11592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11593     typename ResultValueType<void>::type
11594          setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11595                             uint64_t                                 objectHandle,
11596                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11597                             uint64_t                                 data,
11598                             Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11599 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11600 
11601     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11602     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11603                             uint64_t                                 objectHandle,
11604                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11605                             uint64_t *                               pData,
11606                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11607 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11608     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11609     VULKAN_HPP_NODISCARD uint64_t
11610       getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
11611                          uint64_t                                 objectHandle,
11612                          VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
11613                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11614 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11615 
11616     //=== VK_KHR_ray_tracing_pipeline ===
11617 
11618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11619     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(
11620       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
11621       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
11622       uint32_t                                                      createInfoCount,
11623       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
11624       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,
11625       VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,
11626       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11628     template <typename PipelineAllocator = std::allocator<Pipeline>,
11629               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11630     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11631                          createRayTracingPipelinesKHR(
11632                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11633                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11634                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11635                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11636                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11637                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11638     template <typename PipelineAllocator = std::allocator<Pipeline>,
11639               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11640               typename B                 = PipelineAllocator,
11641               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
11642     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
11643                          createRayTracingPipelinesKHR(
11644                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11645                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11646                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11647                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                       allocator,
11648                            PipelineAllocator &                                                             pipelineAllocator,
11649                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11650     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11651     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
11652                          createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
11653                                                       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
11654                                                       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
11655                                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11656                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11657                                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11658 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11659     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11660               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
11661     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
11662                          createRayTracingPipelinesKHRUnique(
11663                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11664                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11665                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11666                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11667                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11668                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11669     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11670               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
11671               typename B                         = PipelineAllocator,
11672               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
11673                                       int>::type = 0>
11674     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
11675                          createRayTracingPipelinesKHRUnique(
11676                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
11677                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
11678                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11679                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>                       allocator,
11680                            PipelineAllocator &                                                             pipelineAllocator,
11681                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11683     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>>
11684       createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11685                                          VULKAN_HPP_NAMESPACE::PipelineCache        pipelineCache,
11686                                          const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
11687                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11688                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11689                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11690 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11691 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11692 
11693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11694     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(
11695       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11696       uint32_t                       firstGroup,
11697       uint32_t                       groupCount,
11698       size_t                         dataSize,
11699       void *                         pData,
11700       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11702     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11703     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11704       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11705                                           uint32_t                       firstGroup,
11706                                           uint32_t                       groupCount,
11707                                           ArrayProxy<T> const &          data,
11708                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11709     template <typename T,
11710               typename Allocator = std::allocator<T>,
11711               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11712     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
11713       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11714                                           uint32_t                       firstGroup,
11715                                           uint32_t                       groupCount,
11716                                           size_t                         dataSize,
11717                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11718     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11719     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
11720       getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11721                                          uint32_t                       firstGroup,
11722                                          uint32_t                       groupCount,
11723                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11724 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11725 
11726     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11727     VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
11728       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11729       uint32_t                       firstGroup,
11730       uint32_t                       groupCount,
11731       size_t                         dataSize,
11732       void *                         pData,
11733       Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11735     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11736     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11737       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11738                                                        uint32_t                       firstGroup,
11739                                                        uint32_t                       groupCount,
11740                                                        ArrayProxy<T> const &          data,
11741                                                        Dispatch const & d
11742                                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11743     template <typename T,
11744               typename Allocator = std::allocator<T>,
11745               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11746     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
11747       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11748                                                        uint32_t                       firstGroup,
11749                                                        uint32_t                       groupCount,
11750                                                        size_t                         dataSize,
11751                                                        Dispatch const & d
11752                                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11753     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11754     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
11755       getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11756                                                       uint32_t                       firstGroup,
11757                                                       uint32_t                       groupCount,
11758                                                       Dispatch const & d
11759                                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11760 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11761 
11762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11763     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
11764                                                      uint32_t                                   group,
11765                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
11766                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11767       VULKAN_HPP_NOEXCEPT;
11768 
11769 #if defined( VK_USE_PLATFORM_FUCHSIA )
11770     //=== VK_FUCHSIA_external_memory ===
11771 
11772     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11773     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA(
11774       const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11775       zx_handle_t *                                                  pZirconHandle,
11776       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11777 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11778     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11779     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
11780       getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11781                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11782 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11783 
11784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11785     VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA(
11786       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
11787       zx_handle_t                                                 zirconHandle,
11788       VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
11789       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11790 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11791     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11792     typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
11793       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11794                                               zx_handle_t                                            zirconHandle,
11795                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11796 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11797 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11798 
11799 #if defined( VK_USE_PLATFORM_FUCHSIA )
11800     //=== VK_FUCHSIA_external_semaphore ===
11801 
11802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11803     VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA(
11804       const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
11805       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11806 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11808     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA(
11809       const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
11810       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11811 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11812 
11813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11814     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA(
11815       const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11816       zx_handle_t *                                                     pZirconHandle,
11817       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11818 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11820     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type getSemaphoreZirconHandleFUCHSIA(
11821       const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11822       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11823 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11824 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11825 
11826 #if defined( VK_USE_PLATFORM_FUCHSIA )
11827     //=== VK_FUCHSIA_buffer_collection ===
11828 
11829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11830     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA(
11831       const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
11832       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
11833       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA *                 pCollection,
11834       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11835 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11837     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11838       typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type
11839       createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
11840                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11841                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11842                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11843 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
11844     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11845     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11846       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type
11847       createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
11848                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11849                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11850                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11851 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11852 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11853 
11854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11855     VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIA(
11856       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
11857       const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
11858       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11859 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11860     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11861     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11862       setBufferCollectionImageConstraintsFUCHSIA(
11863         VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
11864         const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
11865         Dispatch const & d                                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11866 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11867 
11868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11869     VULKAN_HPP_NODISCARD Result setBufferCollectionBufferConstraintsFUCHSIA(
11870       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
11871       const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
11872       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11873 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11875     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11876       setBufferCollectionBufferConstraintsFUCHSIA(
11877         VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA              collection,
11878         const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
11879         Dispatch const & d                                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11880 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11881 
11882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11883     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
11884                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11885                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11886       VULKAN_HPP_NOEXCEPT;
11887 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11889     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11890                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11891                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11892                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11893       VULKAN_HPP_NOEXCEPT;
11894 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11895 
11896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11897     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA     collection,
11898                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11899                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11900 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11902     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11903                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
11904                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11905                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11906 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11907 
11908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11909     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA(
11910       VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA             collection,
11911       VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
11912       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11913 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11915     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11916       typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type
11917       getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
11918                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11919 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11920 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11921 
11922     //=== VK_HUAWEI_subpass_shading ===
11923 
11924     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11925     VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(
11926       VULKAN_HPP_NAMESPACE::RenderPass renderpass,
11927       VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
11928       Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11931     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>
11932                          getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
11933                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11934 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11935 
11936     //=== VK_NV_external_memory_rdma ===
11937 
11938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11939     VULKAN_HPP_NODISCARD Result
11940       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
11941                                 VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,
11942                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11945     typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
11946       getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
11947                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11948 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11949 
11950     //=== VK_EXT_pageable_device_local_memory ===
11951 
11952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11953     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
11954                                float                              priority,
11955                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11956 
11957     //=== VK_KHR_maintenance4 ===
11958 
11959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11960     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR * pInfo,
11961                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11962                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11963       VULKAN_HPP_NOEXCEPT;
11964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11966     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR(
11967       const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info,
11968       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11969     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11970     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR(
11971       const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info,
11972       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11973 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11974 
11975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11976     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR * pInfo,
11977                                         VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11978                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11979       VULKAN_HPP_NOEXCEPT;
11980 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11982     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR(
11983       const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
11984       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11985     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11986     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR(
11987       const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
11988       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11989 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11990 
11991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11992     void getImageSparseMemoryRequirementsKHR(
11993       const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR * pInfo,
11994       uint32_t *                                                     pSparseMemoryRequirementCount,
11995       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *         pSparseMemoryRequirements,
11996       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11998     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
11999               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12000     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12001       getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
12002                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12003     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
12004               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12005               typename B                                       = SparseImageMemoryRequirements2Allocator,
12006               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
12007                                       int>::type               = 0>
12008     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
12009                          getImageSparseMemoryRequirementsKHR(
12010                            const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info,
12011                            SparseImageMemoryRequirements2Allocator &                      sparseImageMemoryRequirements2Allocator,
12012                            Dispatch const & d                                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12013 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12014 
operator VkDevice() const12015     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const VULKAN_HPP_NOEXCEPT
12016     {
12017       return m_device;
12018     }
12019 
operator bool() const12020     explicit operator bool() const VULKAN_HPP_NOEXCEPT
12021     {
12022       return m_device != VK_NULL_HANDLE;
12023     }
12024 
operator !() const12025     bool operator!() const VULKAN_HPP_NOEXCEPT
12026     {
12027       return m_device == VK_NULL_HANDLE;
12028     }
12029 
12030   private:
12031     VkDevice m_device = {};
12032   };
12033   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ),
12034                             "handle and wrapper have different size!" );
12035   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Device>::value,
12036                             "Device is not nothrow_move_constructible!" );
12037 
12038   template <>
12039   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDevice>
12040   {
12041     using type = VULKAN_HPP_NAMESPACE::Device;
12042   };
12043 
12044   template <>
12045   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
12046   {
12047     using Type = VULKAN_HPP_NAMESPACE::Device;
12048   };
12049 
12050   template <>
12051   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
12052                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
12053   {
12054     using Type = VULKAN_HPP_NAMESPACE::Device;
12055   };
12056 
12057   template <>
12058   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
12059   {
12060     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12061   };
12062 
12063   class DisplayModeKHR
12064   {
12065   public:
12066     using CType      = VkDisplayModeKHR;
12067     using NativeType = VkDisplayModeKHR;
12068 
12069     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
12070       VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
12071     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
12072       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
12073 
12074   public:
12075     VULKAN_HPP_CONSTEXPR         DisplayModeKHR() = default;
DisplayModeKHR(std::nullptr_t)12076     VULKAN_HPP_CONSTEXPR         DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)12077     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
12078       : m_displayModeKHR( displayModeKHR )
12079     {}
12080 
12081 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayModeKHR displayModeKHR)12082     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
12083     {
12084       m_displayModeKHR = displayModeKHR;
12085       return *this;
12086     }
12087 #endif
12088 
operator =(std::nullptr_t)12089     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12090     {
12091       m_displayModeKHR = {};
12092       return *this;
12093     }
12094 
12095 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12096     auto operator<=>( DisplayModeKHR const & ) const = default;
12097 #else
operator ==(DisplayModeKHR const & rhs) const12098     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
12099     {
12100       return m_displayModeKHR == rhs.m_displayModeKHR;
12101     }
12102 
operator !=(DisplayModeKHR const & rhs) const12103     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
12104     {
12105       return m_displayModeKHR != rhs.m_displayModeKHR;
12106     }
12107 
operator <(DisplayModeKHR const & rhs) const12108     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
12109     {
12110       return m_displayModeKHR < rhs.m_displayModeKHR;
12111     }
12112 #endif
12113 
operator VkDisplayModeKHR() const12114     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
12115     {
12116       return m_displayModeKHR;
12117     }
12118 
operator bool() const12119     explicit operator bool() const VULKAN_HPP_NOEXCEPT
12120     {
12121       return m_displayModeKHR != VK_NULL_HANDLE;
12122     }
12123 
operator !() const12124     bool operator!() const VULKAN_HPP_NOEXCEPT
12125     {
12126       return m_displayModeKHR == VK_NULL_HANDLE;
12127     }
12128 
12129   private:
12130     VkDisplayModeKHR m_displayModeKHR = {};
12131   };
12132   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ),
12133                             "handle and wrapper have different size!" );
12134   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::value,
12135                             "DisplayModeKHR is not nothrow_move_constructible!" );
12136 
12137   template <>
12138   struct VULKAN_HPP_DEPRECATED(
12139     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayModeKHR>
12140   {
12141     using type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
12142   };
12143 
12144   template <>
12145   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
12146   {
12147     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
12148   };
12149 
12150   template <>
12151   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
12152                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
12153   {
12154     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
12155   };
12156 
12157   template <>
12158   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
12159   {
12160     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12161   };
12162 
12163 #ifndef VULKAN_HPP_NO_SMART_HANDLE
12164   template <typename Dispatch>
12165   class UniqueHandleTraits<Device, Dispatch>
12166   {
12167   public:
12168     using deleter = ObjectDestroy<NoParent, Dispatch>;
12169   };
12170   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
12171 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12172 
12173   class PhysicalDevice
12174   {
12175   public:
12176     using CType      = VkPhysicalDevice;
12177     using NativeType = VkPhysicalDevice;
12178 
12179     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
12180       VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
12181     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
12182       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
12183 
12184   public:
12185     VULKAN_HPP_CONSTEXPR         PhysicalDevice() = default;
PhysicalDevice(std::nullptr_t)12186     VULKAN_HPP_CONSTEXPR         PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PhysicalDevice(VkPhysicalDevice physicalDevice)12187     VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
12188       : m_physicalDevice( physicalDevice )
12189     {}
12190 
12191 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPhysicalDevice physicalDevice)12192     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
12193     {
12194       m_physicalDevice = physicalDevice;
12195       return *this;
12196     }
12197 #endif
12198 
operator =(std::nullptr_t)12199     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12200     {
12201       m_physicalDevice = {};
12202       return *this;
12203     }
12204 
12205 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12206     auto operator<=>( PhysicalDevice const & ) const = default;
12207 #else
operator ==(PhysicalDevice const & rhs) const12208     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
12209     {
12210       return m_physicalDevice == rhs.m_physicalDevice;
12211     }
12212 
operator !=(PhysicalDevice const & rhs) const12213     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
12214     {
12215       return m_physicalDevice != rhs.m_physicalDevice;
12216     }
12217 
operator <(PhysicalDevice const & rhs) const12218     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
12219     {
12220       return m_physicalDevice < rhs.m_physicalDevice;
12221     }
12222 #endif
12223 
12224     //=== VK_VERSION_1_0 ===
12225 
12226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12227     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
12228                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12231     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
12232       getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12233 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12234 
12235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12236     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
12237                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
12238                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12240     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12241     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
12242                          getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
12243                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12244 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12245 
12246     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12247     VULKAN_HPP_NODISCARD Result
12248       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
12249                                 VULKAN_HPP_NAMESPACE::ImageType               type,
12250                                 VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
12251                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
12252                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
12253                                 VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
12254                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12257     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
12258       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                 format,
12259                                 VULKAN_HPP_NAMESPACE::ImageType              type,
12260                                 VULKAN_HPP_NAMESPACE::ImageTiling            tiling,
12261                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags        usage,
12262                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12263                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12264 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12265 
12266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12267     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
12268                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12270     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12271     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
12272       getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12273 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12274 
12275     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12276     void
12277       getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
12278                                 VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
12279                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12280 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12281     template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
12282               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12283     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
12284                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12285     template <
12286       typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
12287       typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12288       typename B                              = QueueFamilyPropertiesAllocator,
12289       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
12290     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
12291                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
12292                                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12293 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12294 
12295     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12296     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
12297                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12300     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
12301       getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12302 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12303 
12304     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12305     VULKAN_HPP_NODISCARD Result
12306       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
12307                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12308                     VULKAN_HPP_NAMESPACE::Device *                    pDevice,
12309                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12312     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
12313       createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo,
12314                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12315                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12316                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12317 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12319     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12320       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
12321       createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo,
12322                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12323                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12324                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12325 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12326 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12327 
12328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12329     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(
12330       const char *                                pLayerName,
12331       uint32_t *                                  pPropertyCount,
12332       VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
12333       Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12335     template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
12336               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12337     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
12338       enumerateDeviceExtensionProperties( Optional<const std::string> layerName
12339                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12340                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12341     template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
12342               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12343               typename B                            = ExtensionPropertiesAllocator,
12344               typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
12345     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
12346       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
12347                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
12348                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12349 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12350 
12351     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12352     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(
12353       uint32_t *                              pPropertyCount,
12354       VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
12355       Dispatch const & d                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12357     template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
12358               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12359     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
12360       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12361     template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
12362               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12363               typename B                        = LayerPropertiesAllocator,
12364               typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
12365     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
12366       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
12367                                       Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12368 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12369 
12370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12371     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
12372                                          VULKAN_HPP_NAMESPACE::ImageType                     type,
12373                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
12374                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
12375                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
12376                                          uint32_t *                                          pPropertyCount,
12377                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
12378                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12379       VULKAN_HPP_NOEXCEPT;
12380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12381     template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
12382               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12383     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
12384                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
12385                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
12386                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
12387                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
12388                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
12389                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12390     template <
12391       typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
12392       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12393       typename B                                    = SparseImageFormatPropertiesAllocator,
12394       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
12395     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
12396                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
12397                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
12398                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
12399                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
12400                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
12401                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
12402                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12403 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12404 
12405     //=== VK_VERSION_1_1 ===
12406 
12407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12408     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
12409                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12412     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
12413       getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12414     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12415     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12416       getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12417 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12418 
12419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12420     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
12421                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12422 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12424     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
12425       getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12426     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12427     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12428       getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12429 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12430 
12431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12432     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
12433                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
12434                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12435 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12437     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
12438                          getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
12439                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12440     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12441     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12442                          getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
12443                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12444 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12445 
12446     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12447     VULKAN_HPP_NODISCARD Result getImageFormatProperties2(
12448       const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
12449       VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
12450       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12453     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
12454       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12455                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12456     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12457     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12458       getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12459                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12460 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12461 
12462     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12463     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
12464                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
12465                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12466       VULKAN_HPP_NOEXCEPT;
12467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12468     template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12469               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12470     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12471                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12472     template <
12473       typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12474       typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12475       typename B                               = QueueFamilyProperties2Allocator,
12476       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
12477     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12478                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
12479                                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12480     template <typename StructureChain,
12481               typename StructureChainAllocator = std::allocator<StructureChain>,
12482               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12483     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12484                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12485     template <typename StructureChain,
12486               typename StructureChainAllocator = std::allocator<StructureChain>,
12487               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12488               typename B                       = StructureChainAllocator,
12489               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
12490     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12491                          getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
12492                                                     Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12493 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12494 
12495     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12496     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
12497                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12499     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12500     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
12501       getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12502     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12503     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12504       getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12505 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12506 
12507     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12508     void getSparseImageFormatProperties2(
12509       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
12510       uint32_t *                                                         pPropertyCount,
12511       VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
12512       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12514     template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12515               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12516     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12517       getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12518                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12519     template <
12520       typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12521       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12522       typename B                                     = SparseImageFormatProperties2Allocator,
12523       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
12524     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12525       getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12526                                        SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
12527                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12528 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12529 
12530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12531     void getExternalBufferProperties(
12532       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
12533       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
12534       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12535 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12536     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12537     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
12538       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
12539       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12540 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12541 
12542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12543     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
12544                                      VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
12545                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12546       VULKAN_HPP_NOEXCEPT;
12547 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12548     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12549     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
12550       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
12551       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12552 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12553 
12554     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12555     void getExternalSemaphoreProperties(
12556       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
12557       VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
12558       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12561     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
12562       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
12563       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12564 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12565 
12566     //=== VK_KHR_surface ===
12567 
12568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12569     VULKAN_HPP_NODISCARD Result
12570       getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
12571                             VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12572                             VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
12573                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12576     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
12577       getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
12578                             VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12579                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12580 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12581 
12582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12583     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(
12584       VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
12585       VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
12586       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12587 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12589     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
12590       getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12591                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12592 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12593 
12594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12595     VULKAN_HPP_NODISCARD Result
12596       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
12597                             uint32_t *                               pSurfaceFormatCount,
12598                             VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
12599                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12600 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12601     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
12602               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12603     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
12604       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12605                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12606     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
12607               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12608               typename B                         = SurfaceFormatKHRAllocator,
12609               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
12610     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
12611       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12612                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
12613                             Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12614 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12615 
12616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12617     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(
12618       VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
12619       uint32_t *                             pPresentModeCount,
12620       VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
12621       Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12622 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12623     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
12624               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12625     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
12626       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12627                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12628     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
12629               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12630               typename B                       = PresentModeKHRAllocator,
12631               typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
12632     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
12633       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12634                                  PresentModeKHRAllocator &        presentModeKHRAllocator,
12635                                  Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12636 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12637 
12638     //=== VK_KHR_swapchain ===
12639 
12640     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12641     VULKAN_HPP_NODISCARD Result
12642       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12643                                uint32_t *                       pRectCount,
12644                                VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
12645                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12646 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12647     template <typename Rect2DAllocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12648     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
12649       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12650                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12651     template <typename Rect2DAllocator = std::allocator<Rect2D>,
12652               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12653               typename B               = Rect2DAllocator,
12654               typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
12655     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
12656       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12657                                Rect2DAllocator &                rect2DAllocator,
12658                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12659 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12660 
12661     //=== VK_KHR_display ===
12662 
12663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12664     VULKAN_HPP_NODISCARD Result
12665       getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
12666                                VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
12667                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12669     template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
12670               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12671     VULKAN_HPP_NODISCARD
12672       typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
12673       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12674     template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
12675               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12676               typename B                             = DisplayPropertiesKHRAllocator,
12677               typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
12678     VULKAN_HPP_NODISCARD
12679       typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
12680       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
12681                                Dispatch const & d              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12682 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12683 
12684     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12685     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(
12686       uint32_t *                                        pPropertyCount,
12687       VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
12688       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12690     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
12691               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12692     VULKAN_HPP_NODISCARD
12693       typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
12694       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12695     template <
12696       typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
12697       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12698       typename B                                  = DisplayPlanePropertiesKHRAllocator,
12699       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
12700     VULKAN_HPP_NODISCARD
12701       typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
12702       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
12703                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12704 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12705 
12706     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12707     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(
12708       uint32_t                           planeIndex,
12709       uint32_t *                         pDisplayCount,
12710       VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
12711       Dispatch const & d                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12713     template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
12714               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12715     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
12716       getDisplayPlaneSupportedDisplaysKHR( uint32_t           planeIndex,
12717                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12718     template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
12719               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12720               typename B                   = DisplayKHRAllocator,
12721               typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
12722     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
12723       getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
12724                                            DisplayKHRAllocator & displayKHRAllocator,
12725                                            Dispatch const & d    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12726 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12727 
12728     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12729     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(
12730       VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
12731       uint32_t *                                       pPropertyCount,
12732       VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
12733       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12735     template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
12736               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12737     VULKAN_HPP_NODISCARD
12738       typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
12739       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12740                                    Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12741     template <
12742       typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
12743       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12744       typename B                                 = DisplayModePropertiesKHRAllocator,
12745       typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
12746     VULKAN_HPP_NODISCARD
12747       typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
12748       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
12749                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
12750                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12751 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12752 
12753     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12754     VULKAN_HPP_NODISCARD Result
12755       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
12756                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
12757                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
12758                             VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
12759                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12762     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
12763       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
12764                             const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo,
12765                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12766                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12767                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12768 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12770     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12771       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
12772       createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
12773                                   const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo,
12774                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
12775                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12776                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12777 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12778 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12779 
12780     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12781     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(
12782       VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
12783       uint32_t                                            planeIndex,
12784       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
12785       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12787     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12788     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12789       typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
12790       getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
12791                                       uint32_t                             planeIndex,
12792                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12793 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12794 
12795 #if defined( VK_USE_PLATFORM_XLIB_KHR )
12796     //=== VK_KHR_xlib_surface ===
12797 
12798     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12799     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
12800                                           Display *          dpy,
12801                                           VisualID           visualID,
12802                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12803       VULKAN_HPP_NOEXCEPT;
12804 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12806     Bool32 getXlibPresentationSupportKHR( uint32_t           queueFamilyIndex,
12807                                           Display &          dpy,
12808                                           VisualID           visualID,
12809                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12810       VULKAN_HPP_NOEXCEPT;
12811 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12812 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/
12813 
12814 #if defined( VK_USE_PLATFORM_XCB_KHR )
12815     //=== VK_KHR_xcb_surface ===
12816 
12817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12818     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
12819                                          xcb_connection_t * connection,
12820                                          xcb_visualid_t     visual_id,
12821                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12822       VULKAN_HPP_NOEXCEPT;
12823 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12825     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
12826                                          xcb_connection_t & connection,
12827                                          xcb_visualid_t     visual_id,
12828                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12829       VULKAN_HPP_NOEXCEPT;
12830 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12831 #endif   /*VK_USE_PLATFORM_XCB_KHR*/
12832 
12833 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
12834     //=== VK_KHR_wayland_surface ===
12835 
12836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12837     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
12838                                              struct wl_display * display,
12839                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12840       VULKAN_HPP_NOEXCEPT;
12841 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12842     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12843     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
12844                                              struct wl_display & display,
12845                                              Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12846       VULKAN_HPP_NOEXCEPT;
12847 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12848 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
12849 
12850 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12851     //=== VK_KHR_win32_surface ===
12852 
12853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12854     Bool32 getWin32PresentationSupportKHR( uint32_t           queueFamilyIndex,
12855                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12856       VULKAN_HPP_NOEXCEPT;
12857 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12858 
12859 #if defined( VK_ENABLE_BETA_EXTENSIONS )
12860     //=== VK_KHR_video_queue ===
12861 
12862     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12863     VULKAN_HPP_NODISCARD Result
12864       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
12865                                VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
12866                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12867 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12869     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
12870       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile,
12871                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12872     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12873     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12874       getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile,
12875                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12876 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12877 
12878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12879     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(
12880       const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
12881       uint32_t *                                                     pVideoFormatPropertyCount,
12882       VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
12883       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12884 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12885     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
12886               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12887     VULKAN_HPP_NODISCARD
12888       typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
12889       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
12890                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12891     template <
12892       typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
12893       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12894       typename B                                 = VideoFormatPropertiesKHRAllocator,
12895       typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
12896     VULKAN_HPP_NODISCARD
12897       typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
12898       getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
12899                                    VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
12900                                    Dispatch const & d                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12901 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12902 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
12903 
12904     //=== VK_NV_external_memory_capabilities ===
12905 
12906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12907     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(
12908       VULKAN_HPP_NAMESPACE::Format                            format,
12909       VULKAN_HPP_NAMESPACE::ImageType                         type,
12910       VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
12911       VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
12912       VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
12913       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
12914       VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
12915       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12916 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12917     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12918     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12919       typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
12920       getExternalImageFormatPropertiesNV(
12921         VULKAN_HPP_NAMESPACE::Format                                             format,
12922         VULKAN_HPP_NAMESPACE::ImageType                                          type,
12923         VULKAN_HPP_NAMESPACE::ImageTiling                                        tiling,
12924         VULKAN_HPP_NAMESPACE::ImageUsageFlags                                    usage,
12925         VULKAN_HPP_NAMESPACE::ImageCreateFlags flags                             VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12926         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12927         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12928 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12929 
12930     //=== VK_KHR_get_physical_device_properties2 ===
12931 
12932     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12933     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
12934                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12935 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12937     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
12938       getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12939     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12940     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12941       getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12942 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12943 
12944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12945     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
12946                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12949     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
12950       getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12951     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12952     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12953       getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12954 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12955 
12956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12957     void
12958       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
12959                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
12960                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12961 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12962     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12963     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
12964                          getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
12965                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12966     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12967     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12968                          getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
12969                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12970 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12971 
12972     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12973     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(
12974       const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
12975       VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
12976       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12977 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12978     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12979     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
12980       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12981                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12982     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12983     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12984       getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12985                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12986 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12987 
12988     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12989     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
12990                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
12991                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12992       VULKAN_HPP_NOEXCEPT;
12993 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12994     template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12995               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12996     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12997       getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12998     template <
12999       typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
13000       typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13001       typename B                               = QueueFamilyProperties2Allocator,
13002       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
13003     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
13004       getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
13005                                     Dispatch const & d                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13006     template <typename StructureChain,
13007               typename StructureChainAllocator = std::allocator<StructureChain>,
13008               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13009     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
13010       getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13011     template <typename StructureChain,
13012               typename StructureChainAllocator = std::allocator<StructureChain>,
13013               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13014               typename B                       = StructureChainAllocator,
13015               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
13016     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
13017                          getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
13018                                                        Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13019 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13020 
13021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13022     void
13023       getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
13024                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13027     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
13028       getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13029     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13030     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
13031       getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13032 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13033 
13034     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13035     void getSparseImageFormatProperties2KHR(
13036       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
13037       uint32_t *                                                         pPropertyCount,
13038       VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
13039       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13040 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13041     template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
13042               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13043     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13044       getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
13045                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13046     template <
13047       typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
13048       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13049       typename B                                     = SparseImageFormatProperties2Allocator,
13050       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
13051     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
13052       getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
13053                                           SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
13054                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13055 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13056 
13057     //=== VK_KHR_external_memory_capabilities ===
13058 
13059     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13060     void getExternalBufferPropertiesKHR(
13061       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
13062       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
13063       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13066     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
13067       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
13068       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13069 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13070 
13071     //=== VK_KHR_external_semaphore_capabilities ===
13072 
13073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13074     void getExternalSemaphorePropertiesKHR(
13075       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
13076       VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
13077       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13080     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
13081       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
13082       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13083 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13084 
13085     //=== VK_EXT_direct_mode_display ===
13086 
13087 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13089     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13090                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13091 #else
13092     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13093     typename ResultValueType<void>::type
13094       releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13095                          Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13096 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13097 
13098 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
13099     //=== VK_EXT_acquire_xlib_display ===
13100 
13101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13102     VULKAN_HPP_NODISCARD Result
13103       acquireXlibDisplayEXT( Display *                        dpy,
13104                              VULKAN_HPP_NAMESPACE::DisplayKHR display,
13105                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13106 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13107     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13108     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13109       acquireXlibDisplayEXT( Display &                        dpy,
13110                              VULKAN_HPP_NAMESPACE::DisplayKHR display,
13111                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13112 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13113 
13114     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13115     VULKAN_HPP_NODISCARD Result
13116       getRandROutputDisplayEXT( Display *                          dpy,
13117                                 RROutput                           rrOutput,
13118                                 VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
13119                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13120 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13121     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13122     typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
13123       Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13124 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13125     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13126     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
13127       getRandROutputDisplayEXTUnique( Display &          dpy,
13128                                       RROutput           rrOutput,
13129                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13130 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13131 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13132 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
13133 
13134     //=== VK_EXT_display_surface_counter ===
13135 
13136     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13137     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(
13138       VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
13139       VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
13140       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13143     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
13144       typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
13145       getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
13146                                   Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13147 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13148 
13149     //=== VK_KHR_external_fence_capabilities ===
13150 
13151     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13152     void getExternalFencePropertiesKHR(
13153       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
13154       VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
13155       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13156 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13157     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13158     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
13159       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
13160       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13161 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13162 
13163     //=== VK_KHR_performance_query ===
13164 
13165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13166     VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(
13167       uint32_t                                                 queueFamilyIndex,
13168       uint32_t *                                               pCounterCount,
13169       VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
13170       VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
13171       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13173     template <typename PerformanceCounterKHRAllocator            = std::allocator<PerformanceCounterKHR>,
13174               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
13175               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13176     VULKAN_HPP_NODISCARD typename ResultValueType<
13177       std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
13178                 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
13179       enumerateQueueFamilyPerformanceQueryCountersKHR(
13180         uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13181     template <typename PerformanceCounterKHRAllocator            = std::allocator<PerformanceCounterKHR>,
13182               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
13183               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13184               typename B1                                        = PerformanceCounterKHRAllocator,
13185               typename B2                                        = PerformanceCounterDescriptionKHRAllocator,
13186               typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
13187                                         std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
13188                                       int>::type                 = 0>
13189     VULKAN_HPP_NODISCARD typename ResultValueType<
13190       std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
13191                 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
13192       enumerateQueueFamilyPerformanceQueryCountersKHR(
13193         uint32_t                                    queueFamilyIndex,
13194         PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
13195         PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
13196         Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13197 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13198 
13199     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13200     void getQueueFamilyPerformanceQueryPassesKHR(
13201       const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
13202       uint32_t *                                                      pNumPasses,
13203       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13204 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13206     VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
13207       const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
13208       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13209 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13210 
13211     //=== VK_KHR_get_surface_capabilities2 ===
13212 
13213     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13214     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(
13215       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13216       VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
13217       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13218 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13220     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
13221       typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
13222       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13223                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13224     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13225     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
13226       getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13227                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13228 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13229 
13230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13231     VULKAN_HPP_NODISCARD Result
13232       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13233                              uint32_t *                                                  pSurfaceFormatCount,
13234                              VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
13235                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13237     template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
13238               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13239     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
13240       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13241                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13242     template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
13243               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13244               typename B                          = SurfaceFormat2KHRAllocator,
13245               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
13246     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
13247       getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13248                              SurfaceFormat2KHRAllocator &                                surfaceFormat2KHRAllocator,
13249                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13250 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13251 
13252     //=== VK_KHR_get_display_properties2 ===
13253 
13254     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13255     VULKAN_HPP_NODISCARD Result
13256       getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
13257                                 VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
13258                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13260     template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
13261               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13262     VULKAN_HPP_NODISCARD
13263       typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
13264       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13265     template <
13266       typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
13267       typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13268       typename B                              = DisplayProperties2KHRAllocator,
13269       typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
13270     VULKAN_HPP_NODISCARD
13271       typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
13272       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
13273                                 Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13274 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13275 
13276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13277     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(
13278       uint32_t *                                         pPropertyCount,
13279       VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
13280       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13281 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13282     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
13283               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13284     VULKAN_HPP_NODISCARD
13285       typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
13286       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13287     template <
13288       typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
13289       typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13290       typename B                                   = DisplayPlaneProperties2KHRAllocator,
13291       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
13292     VULKAN_HPP_NODISCARD
13293       typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
13294       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
13295                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13296 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13297 
13298     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13299     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(
13300       VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
13301       uint32_t *                                        pPropertyCount,
13302       VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
13303       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13305     template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
13306               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13307     VULKAN_HPP_NODISCARD
13308       typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
13309       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13310                                     Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13311     template <
13312       typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
13313       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13314       typename B                                  = DisplayModeProperties2KHRAllocator,
13315       typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
13316     VULKAN_HPP_NODISCARD
13317       typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
13318       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
13319                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
13320                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13321 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13322 
13323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13324     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(
13325       const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
13326       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
13327       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13328 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13330     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
13331       typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
13332       getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,
13333                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13334 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13335 
13336     //=== VK_EXT_sample_locations ===
13337 
13338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13339     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
13340                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
13341                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13342       VULKAN_HPP_NOEXCEPT;
13343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13345     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(
13346       VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
13347       Dispatch const & d                        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13348 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13349 
13350     //=== VK_EXT_calibrated_timestamps ===
13351 
13352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13353     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(
13354       uint32_t *                            pTimeDomainCount,
13355       VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
13356       Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13358     template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
13359               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13360     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
13361       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13362     template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
13363               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13364               typename B                      = TimeDomainEXTAllocator,
13365               typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type = 0>
13366     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
13367       getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator,
13368                                       Dispatch const & d       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13369 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13370 
13371     //=== VK_KHR_fragment_shading_rate ===
13372 
13373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13374     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(
13375       uint32_t *                                                   pFragmentShadingRateCount,
13376       VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
13377       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13378 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13379     template <
13380       typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
13381       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13382     VULKAN_HPP_NODISCARD typename ResultValueType<
13383       std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
13384       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13385     template <
13386       typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
13387       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13388       typename B                                             = PhysicalDeviceFragmentShadingRateKHRAllocator,
13389       typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
13390                               int>::type                     = 0>
13391     VULKAN_HPP_NODISCARD typename ResultValueType<
13392       std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
13393       getFragmentShadingRatesKHR(
13394         PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
13395         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13396 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13397 
13398     //=== VK_EXT_tooling_info ===
13399 
13400     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13401     VULKAN_HPP_NODISCARD Result
13402       getToolPropertiesEXT( uint32_t *                                              pToolCount,
13403                             VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
13404                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13405 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13406     template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
13407               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13408     VULKAN_HPP_NODISCARD typename ResultValueType<
13409       std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
13410       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13411     template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
13412               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13413               typename B                                        = PhysicalDeviceToolPropertiesEXTAllocator,
13414               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
13415                                       int>::type                = 0>
13416     VULKAN_HPP_NODISCARD typename ResultValueType<
13417       std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
13418       getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator,
13419                             Dispatch const & d                         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13420 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13421 
13422     //=== VK_NV_cooperative_matrix ===
13423 
13424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13425     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(
13426       uint32_t *                                            pPropertyCount,
13427       VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
13428       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13430     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
13431               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13432     VULKAN_HPP_NODISCARD
13433       typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
13434       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13435     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
13436               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13437               typename B                                      = CooperativeMatrixPropertiesNVAllocator,
13438               typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
13439                                       int>::type              = 0>
13440     VULKAN_HPP_NODISCARD
13441       typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
13442       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
13443                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13444 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13445 
13446     //=== VK_NV_coverage_reduction_mode ===
13447 
13448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13449     VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(
13450       uint32_t *                                                   pCombinationCount,
13451       VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
13452       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13454     template <
13455       typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
13456       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13457     VULKAN_HPP_NODISCARD typename ResultValueType<
13458       std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
13459       getSupportedFramebufferMixedSamplesCombinationsNV(
13460         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13461     template <
13462       typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
13463       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13464       typename B                                             = FramebufferMixedSamplesCombinationNVAllocator,
13465       typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
13466                               int>::type                     = 0>
13467     VULKAN_HPP_NODISCARD typename ResultValueType<
13468       std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
13469       getSupportedFramebufferMixedSamplesCombinationsNV(
13470         FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
13471         Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13472 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13473 
13474 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13475     //=== VK_EXT_full_screen_exclusive ===
13476 
13477     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13478     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT(
13479       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
13480       uint32_t *                                                  pPresentModeCount,
13481       VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
13482       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13483 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13484     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
13485               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13486     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
13487       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13488                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13489     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
13490               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13491               typename B                       = PresentModeKHRAllocator,
13492               typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
13493     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
13494       getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
13495                                   PresentModeKHRAllocator &                                   presentModeKHRAllocator,
13496                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13497 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13498 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
13499 
13500     //=== VK_EXT_acquire_drm_display ===
13501 
13502 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13503     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13504     VULKAN_HPP_NODISCARD Result
13505       acquireDrmDisplayEXT( int32_t                          drmFd,
13506                             VULKAN_HPP_NAMESPACE::DisplayKHR display,
13507                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13508 #else
13509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13510     typename ResultValueType<void>::type
13511          acquireDrmDisplayEXT( int32_t                          drmFd,
13512                                VULKAN_HPP_NAMESPACE::DisplayKHR display,
13513                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13514 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13515 
13516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13517     VULKAN_HPP_NODISCARD Result
13518       getDrmDisplayEXT( int32_t                            drmFd,
13519                         uint32_t                           connectorId,
13520                         VULKAN_HPP_NAMESPACE::DisplayKHR * display,
13521                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13522 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13523     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13524     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
13525       getDrmDisplayEXT( int32_t            drmFd,
13526                         uint32_t           connectorId,
13527                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13528 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13530     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13531       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
13532       getDrmDisplayEXTUnique( int32_t            drmFd,
13533                               uint32_t           connectorId,
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 
13538 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13539     //=== VK_NV_acquire_winrt_display ===
13540 
13541 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13543     VULKAN_HPP_NODISCARD Result
13544       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13545                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13546 #  else
13547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13548     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
13549       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
13550                              Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13551 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13552 
13553     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13554     VULKAN_HPP_NODISCARD Result
13555       getWinrtDisplayNV( uint32_t                           deviceRelativeId,
13556                          VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
13557                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13558 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13559     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13560     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
13561       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13562 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13563     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13564     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13565       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
13566       getWinrtDisplayNVUnique( uint32_t           deviceRelativeId,
13567                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13568 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13569 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13570 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
13571 
13572 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
13573     //=== VK_EXT_directfb_surface ===
13574 
13575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13576     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
13577                                               IDirectFB *        dfb,
13578                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13579       VULKAN_HPP_NOEXCEPT;
13580 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13581     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13582     Bool32 getDirectFBPresentationSupportEXT( uint32_t           queueFamilyIndex,
13583                                               IDirectFB &        dfb,
13584                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13585       VULKAN_HPP_NOEXCEPT;
13586 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13587 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
13588 
13589 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
13590     //=== VK_QNX_screen_surface ===
13591 
13592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13593     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
13594                                             struct _screen_window * window,
13595                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13596       VULKAN_HPP_NOEXCEPT;
13597 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13599     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
13600                                             struct _screen_window & window,
13601                                             Dispatch const & d      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13602       VULKAN_HPP_NOEXCEPT;
13603 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13604 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
13605 
operator VkPhysicalDevice() const13606     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
13607     {
13608       return m_physicalDevice;
13609     }
13610 
operator bool() const13611     explicit operator bool() const VULKAN_HPP_NOEXCEPT
13612     {
13613       return m_physicalDevice != VK_NULL_HANDLE;
13614     }
13615 
operator !() const13616     bool operator!() const VULKAN_HPP_NOEXCEPT
13617     {
13618       return m_physicalDevice == VK_NULL_HANDLE;
13619     }
13620 
13621   private:
13622     VkPhysicalDevice m_physicalDevice = {};
13623   };
13624   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ),
13625                             "handle and wrapper have different size!" );
13626   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevice>::value,
13627                             "PhysicalDevice is not nothrow_move_constructible!" );
13628 
13629   template <>
13630   struct VULKAN_HPP_DEPRECATED(
13631     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePhysicalDevice>
13632   {
13633     using type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
13634   };
13635 
13636   template <>
13637   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
13638   {
13639     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
13640   };
13641 
13642   template <>
13643   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
13644                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
13645   {
13646     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
13647   };
13648 
13649   template <>
13650   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
13651   {
13652     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
13653   };
13654 
13655 #ifndef VULKAN_HPP_NO_SMART_HANDLE
13656   class Instance;
13657   template <typename Dispatch>
13658   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
13659   {
13660   public:
13661     using deleter = ObjectDestroy<Instance, Dispatch>;
13662   };
13663   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13664   template <typename Dispatch>
13665   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
13666   {
13667   public:
13668     using deleter = ObjectDestroy<Instance, Dispatch>;
13669   };
13670   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13671   template <typename Dispatch>
13672   class UniqueHandleTraits<SurfaceKHR, Dispatch>
13673   {
13674   public:
13675     using deleter = ObjectDestroy<Instance, Dispatch>;
13676   };
13677   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13678 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13679 
13680   class Instance
13681   {
13682   public:
13683     using CType      = VkInstance;
13684     using NativeType = VkInstance;
13685 
13686     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
13687       VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
13688     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
13689       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
13690 
13691   public:
13692     VULKAN_HPP_CONSTEXPR         Instance() = default;
Instance(std::nullptr_t)13693     VULKAN_HPP_CONSTEXPR         Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Instance(VkInstance instance)13694     VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
13695 
13696 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkInstance instance)13697     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
13698     {
13699       m_instance = instance;
13700       return *this;
13701     }
13702 #endif
13703 
operator =(std::nullptr_t)13704     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
13705     {
13706       m_instance = {};
13707       return *this;
13708     }
13709 
13710 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
13711     auto operator<=>( Instance const & ) const = default;
13712 #else
operator ==(Instance const & rhs) const13713     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13714     {
13715       return m_instance == rhs.m_instance;
13716     }
13717 
operator !=(Instance const & rhs) const13718     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13719     {
13720       return m_instance != rhs.m_instance;
13721     }
13722 
operator <(Instance const & rhs) const13723     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
13724     {
13725       return m_instance < rhs.m_instance;
13726     }
13727 #endif
13728 
13729     //=== VK_VERSION_1_0 ===
13730 
13731     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13732     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13733                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13735     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13736     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13737                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13738                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13739 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13740 
13741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13742     VULKAN_HPP_NODISCARD Result
13743       enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
13744                                 VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
13745                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13746 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13747     template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
13748               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13749     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
13750       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13751     template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
13752               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13753               typename B                       = PhysicalDeviceAllocator,
13754               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type = 0>
13755     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
13756       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator,
13757                                 Dispatch const & d        VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13758 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13759 
13760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13761     PFN_vkVoidFunction
13762       getProcAddr( const char *       pName,
13763                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13764 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13765     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13766     PFN_vkVoidFunction
13767       getProcAddr( const std::string & name,
13768                    Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13769 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13770 
13771     //=== VK_VERSION_1_1 ===
13772 
13773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13774     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(
13775       uint32_t *                                            pPhysicalDeviceGroupCount,
13776       VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
13777       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13778 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13779     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
13780               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13781     VULKAN_HPP_NODISCARD
13782       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13783       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13784     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
13785               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13786               typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
13787               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
13788                                       int>::type              = 0>
13789     VULKAN_HPP_NODISCARD
13790       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13791       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
13792                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13793 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13794 
13795     //=== VK_KHR_surface ===
13796 
13797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13798     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
13799                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13800                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13803     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13804                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13805                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13806                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13807 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13808 
13809     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13810     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
13811                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13812                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13815     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
13816                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13817                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13818                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13819 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13820 
13821     //=== VK_KHR_display ===
13822 
13823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13824     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(
13825       const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
13826       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13827       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13828       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13829 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13831     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13832       createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo,
13833                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13834                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13835                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13836 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13838     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13839       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13840       createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo,
13841                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13842                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13843                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13844 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13845 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13846 
13847 #if defined( VK_USE_PLATFORM_XLIB_KHR )
13848     //=== VK_KHR_xlib_surface ===
13849 
13850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13851     VULKAN_HPP_NODISCARD Result
13852       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
13853                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
13854                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
13855                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13856 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13857     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13858     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13859       createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
13860                             Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13861                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13862                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13863 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13865     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13866       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13867       createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
13868                                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13869                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13870                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13871 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13872 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13873 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/
13874 
13875 #if defined( VK_USE_PLATFORM_XCB_KHR )
13876     //=== VK_KHR_xcb_surface ===
13877 
13878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13879     VULKAN_HPP_NODISCARD Result
13880       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
13881                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
13882                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
13883                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13884 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13886     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13887       createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
13888                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13889                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13890                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13891 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13892     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13893     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13894       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13895       createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
13896                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13897                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13898                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13899 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13900 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13901 #endif     /*VK_USE_PLATFORM_XCB_KHR*/
13902 
13903 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13904     //=== VK_KHR_wayland_surface ===
13905 
13906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13907     VULKAN_HPP_NODISCARD Result
13908       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
13909                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13910                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13911                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13912 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13913     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13914     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13915       createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
13916                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13917                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13918                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13919 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13920     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13921     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13922       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13923       createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
13924                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13925                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13926                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13927 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13928 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13929 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
13930 
13931 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
13932     //=== VK_KHR_android_surface ===
13933 
13934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13935     VULKAN_HPP_NODISCARD Result
13936       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
13937                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13938                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13939                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13940 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13942     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13943       createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
13944                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13945                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13946                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13947 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13949     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13950       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13951       createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
13952                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13953                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13954                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13955 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13956 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13957 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
13958 
13959 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13960     //=== VK_KHR_win32_surface ===
13961 
13962     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13963     VULKAN_HPP_NODISCARD Result
13964       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
13965                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
13966                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
13967                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13968 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13970     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13971       createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
13972                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13973                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13974                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13975 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13977     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13978       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13979       createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
13980                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
13981                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13982                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13983 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13984 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13985 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
13986 
13987 #if defined( VK_USE_PLATFORM_OHOS_OPENHARMONY )
13988     //=== VK_OpenHarmony_OHOS_surface ===
13989 
13990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13991     VULKAN_HPP_NODISCARD Result
13992       createOHOSSurfaceOpenHarmony( const VULKAN_HPP_NAMESPACE::OHOSSurfaceCreateInfoOpenHarmony * pCreateInfo,
13993                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13994                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13995                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13996 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13998     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13999       createOHOSSurfaceOpenHarmony( const VULKAN_HPP_NAMESPACE::OHOSSurfaceCreateInfoOpenHarmony & createInfo,
14000                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14001                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14002                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14003 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14005     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14006       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14007       createOHOSSurfaceOpenHarmonyUnique( const VULKAN_HPP_NAMESPACE::OHOSSurfaceCreateInfoOpenHarmony & createInfo,
14008                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14009                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14010                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14011 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14012 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14013 #endif     /*VK_USE_PLATFORM_OHOS_OPENHARMONY*/
14014 
14015     //=== VK_EXT_debug_report ===
14016 
14017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14018     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
14019       const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
14020       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
14021       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
14022       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14023 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14025     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type
14026       createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo,
14027                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14028                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14029                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14030 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14031     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14032     VULKAN_HPP_INLINE
14033       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
14034       createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo,
14035                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14036                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14037                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14038 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14039 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14040 
14041     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14042     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
14043                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14044                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14045       VULKAN_HPP_NOEXCEPT;
14046 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14048     void destroyDebugReportCallbackEXT(
14049       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14050       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14051                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14052       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14053 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14054 
14055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14056     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
14057                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14058                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14061     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
14062                   Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14063                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14064                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14065 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14066 
14067     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14068     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
14069                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
14070                                 uint64_t                                       object,
14071                                 size_t                                         location,
14072                                 int32_t                                        messageCode,
14073                                 const char *                                   pLayerPrefix,
14074                                 const char *                                   pMessage,
14075                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14077     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14078     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
14079                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
14080                                 uint64_t                                       object,
14081                                 size_t                                         location,
14082                                 int32_t                                        messageCode,
14083                                 const std::string &                            layerPrefix,
14084                                 const std::string &                            message,
14085                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14086 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14087 
14088 #if defined( VK_USE_PLATFORM_GGP )
14089     //=== VK_GGP_stream_descriptor_surface ===
14090 
14091     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14092     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP(
14093       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
14094       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
14095       VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
14096       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14097 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14098     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14099     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14100       createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
14101                                         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14102                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14103                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14104 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14106     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14107       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14108       createStreamDescriptorSurfaceGGPUnique(
14109         const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
14110         Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14111                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14112         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14113 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14114 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14115 #endif     /*VK_USE_PLATFORM_GGP*/
14116 
14117 #if defined( VK_USE_PLATFORM_VI_NN )
14118     //=== VK_NN_vi_surface ===
14119 
14120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14121     VULKAN_HPP_NODISCARD Result
14122       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
14123                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
14124                          VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
14125                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14126 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14127     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14128     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14129       createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
14130                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14131                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14132                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14133 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14135     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14136       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14137       createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
14138                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14139                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14140                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14141 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14142 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14143 #endif     /*VK_USE_PLATFORM_VI_NN*/
14144 
14145     //=== VK_KHR_device_group_creation ===
14146 
14147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14148     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(
14149       uint32_t *                                            pPhysicalDeviceGroupCount,
14150       VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
14151       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14152 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14153     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
14154               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14155     VULKAN_HPP_NODISCARD
14156       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
14157       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14158     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
14159               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14160               typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
14161               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
14162                                       int>::type              = 0>
14163     VULKAN_HPP_NODISCARD
14164       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
14165       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
14166                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14167 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14168 
14169 #if defined( VK_USE_PLATFORM_IOS_MVK )
14170     //=== VK_MVK_ios_surface ===
14171 
14172     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14173     VULKAN_HPP_NODISCARD Result
14174       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
14175                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
14176                            VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
14177                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14178 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14179     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14180     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14181       createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
14182                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14183                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14184                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14185 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14187     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14188       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14189       createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
14190                                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14191                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14192                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14193 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14194 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14195 #endif     /*VK_USE_PLATFORM_IOS_MVK*/
14196 
14197 #if defined( VK_USE_PLATFORM_MACOS_MVK )
14198     //=== VK_MVK_macos_surface ===
14199 
14200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14201     VULKAN_HPP_NODISCARD Result
14202       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
14203                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
14204                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
14205                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14206 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14207     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14208     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14209       createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
14210                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14211                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14212                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14213 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14215     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14216       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14217       createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
14218                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14219                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14220                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14221 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14222 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14223 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/
14224 
14225     //=== VK_EXT_debug_utils ===
14226 
14227     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14228     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
14229       const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
14230       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
14231       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
14232       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14233 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14235     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type
14236       createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo,
14237                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14238                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14239                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14240 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14242     VULKAN_HPP_INLINE
14243       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
14244       createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo,
14245                                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14246                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14247                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14248 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14249 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14250 
14251     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14252     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
14253                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14254                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14255       VULKAN_HPP_NOEXCEPT;
14256 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14258     void destroyDebugUtilsMessengerEXT(
14259       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14260       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14261                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14262       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14264 
14265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14266     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
14267                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14268                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14270     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14271     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
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 VULKAN_HPP_NOEXCEPT;
14275 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14276 
14277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14278     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
14279                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
14280                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
14281                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14282       VULKAN_HPP_NOEXCEPT;
14283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14284     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14285     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
14286                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
14287                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,
14288                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
14289       VULKAN_HPP_NOEXCEPT;
14290 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14291 
14292 #if defined( VK_USE_PLATFORM_FUCHSIA )
14293     //=== VK_FUCHSIA_imagepipe_surface ===
14294 
14295     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14296     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA(
14297       const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
14298       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
14299       VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
14300       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14301 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14303     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14304       createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
14305                                      Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14306                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14307                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14308 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14309     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14310     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14311       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14312       createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
14313                                            Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14314                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14315                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14316 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14317 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14318 #endif     /*VK_USE_PLATFORM_FUCHSIA*/
14319 
14320 #if defined( VK_USE_PLATFORM_METAL_EXT )
14321     //=== VK_EXT_metal_surface ===
14322 
14323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14324     VULKAN_HPP_NODISCARD Result
14325       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
14326                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
14327                              VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
14328                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14329 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14331     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14332       createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
14333                              Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14334                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14335                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14336 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14338     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14339       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14340       createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
14341                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14342                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14343                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14344 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14345 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14346 #endif     /*VK_USE_PLATFORM_METAL_EXT*/
14347 
14348     //=== VK_EXT_headless_surface ===
14349 
14350     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14351     VULKAN_HPP_NODISCARD Result
14352       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
14353                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
14354                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
14355                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14357     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14358     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14359       createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo,
14360                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14361                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14362                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14363 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14364     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14365     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14366       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14367       createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo,
14368                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14369                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14370                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14371 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14372 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14373 
14374 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
14375     //=== VK_EXT_directfb_surface ===
14376 
14377     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14378     VULKAN_HPP_NODISCARD Result
14379       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
14380                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
14381                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
14382                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14383 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14385     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14386       createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
14387                                 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14388                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14389                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14390 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14392     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14393       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14394       createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
14395                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14396                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14397                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14398 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14399 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14400 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
14401 
14402 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
14403     //=== VK_QNX_screen_surface ===
14404 
14405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14406     VULKAN_HPP_NODISCARD Result
14407       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
14408                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
14409                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
14410                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14411 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14413     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
14414       createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
14415                               Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14416                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14417                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14418 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
14419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14420     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14421       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
14422       createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
14423                                     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14424                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14425                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14426 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14427 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14428 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
14429 
operator VkInstance() const14430     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const VULKAN_HPP_NOEXCEPT
14431     {
14432       return m_instance;
14433     }
14434 
operator bool() const14435     explicit operator bool() const VULKAN_HPP_NOEXCEPT
14436     {
14437       return m_instance != VK_NULL_HANDLE;
14438     }
14439 
operator !() const14440     bool operator!() const VULKAN_HPP_NOEXCEPT
14441     {
14442       return m_instance == VK_NULL_HANDLE;
14443     }
14444 
14445   private:
14446     VkInstance m_instance = {};
14447   };
14448   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ),
14449                             "handle and wrapper have different size!" );
14450   VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Instance>::value,
14451                             "Instance is not nothrow_move_constructible!" );
14452 
14453   template <>
14454   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eInstance>
14455   {
14456     using type = VULKAN_HPP_NAMESPACE::Instance;
14457   };
14458 
14459   template <>
14460   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
14461   {
14462     using Type = VULKAN_HPP_NAMESPACE::Instance;
14463   };
14464 
14465   template <>
14466   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
14467                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
14468   {
14469     using Type = VULKAN_HPP_NAMESPACE::Instance;
14470   };
14471 
14472   template <>
14473   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
14474   {
14475     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
14476   };
14477 
14478   //=== VK_VERSION_1_0 ===
14479 
14480 #ifndef VULKAN_HPP_NO_SMART_HANDLE
14481   template <typename Dispatch>
14482   class UniqueHandleTraits<Instance, Dispatch>
14483   {
14484   public:
14485     using deleter = ObjectDestroy<NoParent, Dispatch>;
14486   };
14487   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
14488 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14489 
14490   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14491   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
14492                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14493                                               VULKAN_HPP_NAMESPACE::Instance *                  pInstance,
14494                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
14495     VULKAN_HPP_NOEXCEPT;
14496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14497   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14498   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance(
14499     const VULKAN_HPP_NAMESPACE::InstanceCreateInfo &                    createInfo,
14500     Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14501     Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14502 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
14503   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14504   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
14505     typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
14506     createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo,
14507                           Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
14508                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14509                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14510 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
14511 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14512 
14513   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14514   VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties(
14515     const char *                                pLayerName,
14516     uint32_t *                                  pPropertyCount,
14517     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
14518     Dispatch const & d                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
14519 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14520   template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
14521             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14522   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
14523     enumerateInstanceExtensionProperties( Optional<const std::string> layerName
14524                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
14525                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14526   template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
14527             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14528             typename B                            = ExtensionPropertiesAllocator,
14529             typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
14530   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
14531     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
14532                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
14533                                           Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14534 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14535 
14536   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14537   VULKAN_HPP_NODISCARD Result
14538     enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
14539                                       VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
14540                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
14541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14542   template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
14543             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14544   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
14545     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14546   template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
14547             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14548             typename B                        = LayerPropertiesAllocator,
14549             typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
14550   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
14551     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
14552                                       Dispatch const & d         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14553 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14554 
14555   //=== VK_VERSION_1_1 ===
14556 
14557   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14558   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion(
14559     uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
14560 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14561   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14562   typename ResultValueType<uint32_t>::type
14563     enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
14564 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14565 
14566 }  // namespace VULKAN_HPP_NAMESPACE
14567 #endif
14568