• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2015-2022 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HANDLES_HPP
9 #  define VULKAN_HANDLES_HPP
10 
11 namespace VULKAN_HPP_NAMESPACE
12 {
13 
14   //===================================
15   //=== STRUCT forward declarations ===
16   //===================================
17 
18 
19   //=== VK_VERSION_1_0 ===
20   struct Extent2D;
21   struct Extent3D;
22   struct Offset2D;
23   struct Offset3D;
24   struct Rect2D;
25   struct BaseInStructure;
26   struct BaseOutStructure;
27   struct BufferMemoryBarrier;
28   struct DispatchIndirectCommand;
29   struct DrawIndexedIndirectCommand;
30   struct DrawIndirectCommand;
31   struct ImageMemoryBarrier;
32   struct MemoryBarrier;
33   struct PipelineCacheHeaderVersionOne;
34   struct AllocationCallbacks;
35   struct ApplicationInfo;
36   struct FormatProperties;
37   struct ImageFormatProperties;
38   struct InstanceCreateInfo;
39   struct MemoryHeap;
40   struct MemoryType;
41   struct PhysicalDeviceFeatures;
42   struct PhysicalDeviceLimits;
43   struct PhysicalDeviceMemoryProperties;
44   struct PhysicalDeviceProperties;
45   struct PhysicalDeviceSparseProperties;
46   struct QueueFamilyProperties;
47   struct DeviceCreateInfo;
48   struct DeviceQueueCreateInfo;
49   struct ExtensionProperties;
50   struct LayerProperties;
51   struct SubmitInfo;
52   struct MappedMemoryRange;
53   struct MemoryAllocateInfo;
54   struct MemoryRequirements;
55   struct BindSparseInfo;
56   struct ImageSubresource;
57   struct SparseBufferMemoryBindInfo;
58   struct SparseImageFormatProperties;
59   struct SparseImageMemoryBind;
60   struct SparseImageMemoryBindInfo;
61   struct SparseImageMemoryRequirements;
62   struct SparseImageOpaqueMemoryBindInfo;
63   struct SparseMemoryBind;
64   struct FenceCreateInfo;
65   struct SemaphoreCreateInfo;
66   struct EventCreateInfo;
67   struct QueryPoolCreateInfo;
68   struct BufferCreateInfo;
69   struct BufferViewCreateInfo;
70   struct ImageCreateInfo;
71   struct SubresourceLayout;
72   struct ComponentMapping;
73   struct ImageSubresourceRange;
74   struct ImageViewCreateInfo;
75   struct ShaderModuleCreateInfo;
76   struct PipelineCacheCreateInfo;
77   struct ComputePipelineCreateInfo;
78   struct GraphicsPipelineCreateInfo;
79   struct PipelineColorBlendAttachmentState;
80   struct PipelineColorBlendStateCreateInfo;
81   struct PipelineDepthStencilStateCreateInfo;
82   struct PipelineDynamicStateCreateInfo;
83   struct PipelineInputAssemblyStateCreateInfo;
84   struct PipelineMultisampleStateCreateInfo;
85   struct PipelineRasterizationStateCreateInfo;
86   struct PipelineShaderStageCreateInfo;
87   struct PipelineTessellationStateCreateInfo;
88   struct PipelineVertexInputStateCreateInfo;
89   struct PipelineViewportStateCreateInfo;
90   struct SpecializationInfo;
91   struct SpecializationMapEntry;
92   struct StencilOpState;
93   struct VertexInputAttributeDescription;
94   struct VertexInputBindingDescription;
95   struct Viewport;
96   struct PipelineLayoutCreateInfo;
97   struct PushConstantRange;
98   struct SamplerCreateInfo;
99   struct CopyDescriptorSet;
100   struct DescriptorBufferInfo;
101   struct DescriptorImageInfo;
102   struct DescriptorPoolCreateInfo;
103   struct DescriptorPoolSize;
104   struct DescriptorSetAllocateInfo;
105   struct DescriptorSetLayoutBinding;
106   struct DescriptorSetLayoutCreateInfo;
107   struct WriteDescriptorSet;
108   struct AttachmentDescription;
109   struct AttachmentReference;
110   struct FramebufferCreateInfo;
111   struct RenderPassCreateInfo;
112   struct SubpassDependency;
113   struct SubpassDescription;
114   struct CommandPoolCreateInfo;
115   struct CommandBufferAllocateInfo;
116   struct CommandBufferBeginInfo;
117   struct CommandBufferInheritanceInfo;
118   struct BufferCopy;
119   struct BufferImageCopy;
120   struct ClearAttachment;
121   union ClearColorValue;
122   struct ClearDepthStencilValue;
123   struct ClearRect;
124   union ClearValue;
125   struct ImageBlit;
126   struct ImageCopy;
127   struct ImageResolve;
128   struct ImageSubresourceLayers;
129   struct RenderPassBeginInfo;
130 
131   //=== VK_VERSION_1_1 ===
132   struct PhysicalDeviceSubgroupProperties;
133   struct BindBufferMemoryInfo;
134   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
135   struct BindImageMemoryInfo;
136   using BindImageMemoryInfoKHR = BindImageMemoryInfo;
137   struct PhysicalDevice16BitStorageFeatures;
138   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
139   struct MemoryDedicatedRequirements;
140   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
141   struct MemoryDedicatedAllocateInfo;
142   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
143   struct MemoryAllocateFlagsInfo;
144   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
145   struct DeviceGroupRenderPassBeginInfo;
146   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
147   struct DeviceGroupCommandBufferBeginInfo;
148   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
149   struct DeviceGroupSubmitInfo;
150   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
151   struct DeviceGroupBindSparseInfo;
152   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
153   struct BindBufferMemoryDeviceGroupInfo;
154   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
155   struct BindImageMemoryDeviceGroupInfo;
156   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
157   struct PhysicalDeviceGroupProperties;
158   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
159   struct DeviceGroupDeviceCreateInfo;
160   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
161   struct BufferMemoryRequirementsInfo2;
162   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
163   struct ImageMemoryRequirementsInfo2;
164   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
165   struct ImageSparseMemoryRequirementsInfo2;
166   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
167   struct MemoryRequirements2;
168   using MemoryRequirements2KHR = MemoryRequirements2;
169   struct SparseImageMemoryRequirements2;
170   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
171   struct PhysicalDeviceFeatures2;
172   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
173   struct PhysicalDeviceProperties2;
174   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
175   struct FormatProperties2;
176   using FormatProperties2KHR = FormatProperties2;
177   struct ImageFormatProperties2;
178   using ImageFormatProperties2KHR = ImageFormatProperties2;
179   struct PhysicalDeviceImageFormatInfo2;
180   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
181   struct QueueFamilyProperties2;
182   using QueueFamilyProperties2KHR = QueueFamilyProperties2;
183   struct PhysicalDeviceMemoryProperties2;
184   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
185   struct SparseImageFormatProperties2;
186   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
187   struct PhysicalDeviceSparseImageFormatInfo2;
188   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
189   struct PhysicalDevicePointClippingProperties;
190   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
191   struct RenderPassInputAttachmentAspectCreateInfo;
192   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
193   struct InputAttachmentAspectReference;
194   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
195   struct ImageViewUsageCreateInfo;
196   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
197   struct PipelineTessellationDomainOriginStateCreateInfo;
198   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
199   struct RenderPassMultiviewCreateInfo;
200   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
201   struct PhysicalDeviceMultiviewFeatures;
202   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
203   struct PhysicalDeviceMultiviewProperties;
204   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
205   struct PhysicalDeviceVariablePointersFeatures;
206   using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
207   using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
208   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
209   struct PhysicalDeviceProtectedMemoryFeatures;
210   struct PhysicalDeviceProtectedMemoryProperties;
211   struct DeviceQueueInfo2;
212   struct ProtectedSubmitInfo;
213   struct SamplerYcbcrConversionCreateInfo;
214   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
215   struct SamplerYcbcrConversionInfo;
216   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
217   struct BindImagePlaneMemoryInfo;
218   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
219   struct ImagePlaneMemoryRequirementsInfo;
220   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
221   struct PhysicalDeviceSamplerYcbcrConversionFeatures;
222   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
223   struct SamplerYcbcrConversionImageFormatProperties;
224   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
225   struct DescriptorUpdateTemplateEntry;
226   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
227   struct DescriptorUpdateTemplateCreateInfo;
228   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
229   struct ExternalMemoryProperties;
230   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
231   struct PhysicalDeviceExternalImageFormatInfo;
232   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
233   struct ExternalImageFormatProperties;
234   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
235   struct PhysicalDeviceExternalBufferInfo;
236   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
237   struct ExternalBufferProperties;
238   using ExternalBufferPropertiesKHR = ExternalBufferProperties;
239   struct PhysicalDeviceIDProperties;
240   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
241   struct ExternalMemoryImageCreateInfo;
242   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
243   struct ExternalMemoryBufferCreateInfo;
244   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
245   struct ExportMemoryAllocateInfo;
246   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
247   struct PhysicalDeviceExternalFenceInfo;
248   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
249   struct ExternalFenceProperties;
250   using ExternalFencePropertiesKHR = ExternalFenceProperties;
251   struct ExportFenceCreateInfo;
252   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
253   struct ExportSemaphoreCreateInfo;
254   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
255   struct PhysicalDeviceExternalSemaphoreInfo;
256   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
257   struct ExternalSemaphoreProperties;
258   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
259   struct PhysicalDeviceMaintenance3Properties;
260   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
261   struct DescriptorSetLayoutSupport;
262   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
263   struct PhysicalDeviceShaderDrawParametersFeatures;
264   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
265 
266   //=== VK_VERSION_1_2 ===
267   struct PhysicalDeviceVulkan11Features;
268   struct PhysicalDeviceVulkan11Properties;
269   struct PhysicalDeviceVulkan12Features;
270   struct PhysicalDeviceVulkan12Properties;
271   struct ImageFormatListCreateInfo;
272   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
273   struct RenderPassCreateInfo2;
274   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
275   struct AttachmentDescription2;
276   using AttachmentDescription2KHR = AttachmentDescription2;
277   struct AttachmentReference2;
278   using AttachmentReference2KHR = AttachmentReference2;
279   struct SubpassDescription2;
280   using SubpassDescription2KHR = SubpassDescription2;
281   struct SubpassDependency2;
282   using SubpassDependency2KHR = SubpassDependency2;
283   struct SubpassBeginInfo;
284   using SubpassBeginInfoKHR = SubpassBeginInfo;
285   struct SubpassEndInfo;
286   using SubpassEndInfoKHR = SubpassEndInfo;
287   struct PhysicalDevice8BitStorageFeatures;
288   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
289   struct ConformanceVersion;
290   using ConformanceVersionKHR = ConformanceVersion;
291   struct PhysicalDeviceDriverProperties;
292   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
293   struct PhysicalDeviceShaderAtomicInt64Features;
294   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
295   struct PhysicalDeviceShaderFloat16Int8Features;
296   using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
297   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
298   struct PhysicalDeviceFloatControlsProperties;
299   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
300   struct DescriptorSetLayoutBindingFlagsCreateInfo;
301   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
302   struct PhysicalDeviceDescriptorIndexingFeatures;
303   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
304   struct PhysicalDeviceDescriptorIndexingProperties;
305   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
306   struct DescriptorSetVariableDescriptorCountAllocateInfo;
307   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
308   struct DescriptorSetVariableDescriptorCountLayoutSupport;
309   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
310   struct SubpassDescriptionDepthStencilResolve;
311   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
312   struct PhysicalDeviceDepthStencilResolveProperties;
313   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
314   struct PhysicalDeviceScalarBlockLayoutFeatures;
315   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
316   struct ImageStencilUsageCreateInfo;
317   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
318   struct SamplerReductionModeCreateInfo;
319   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
320   struct PhysicalDeviceSamplerFilterMinmaxProperties;
321   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
322   struct PhysicalDeviceVulkanMemoryModelFeatures;
323   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
324   struct PhysicalDeviceImagelessFramebufferFeatures;
325   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
326   struct FramebufferAttachmentsCreateInfo;
327   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
328   struct FramebufferAttachmentImageInfo;
329   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
330   struct RenderPassAttachmentBeginInfo;
331   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
332   struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
333   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
334   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
335   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
336   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
337   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
338   struct AttachmentReferenceStencilLayout;
339   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
340   struct AttachmentDescriptionStencilLayout;
341   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
342   struct PhysicalDeviceHostQueryResetFeatures;
343   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
344   struct PhysicalDeviceTimelineSemaphoreFeatures;
345   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
346   struct PhysicalDeviceTimelineSemaphoreProperties;
347   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
348   struct SemaphoreTypeCreateInfo;
349   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
350   struct TimelineSemaphoreSubmitInfo;
351   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
352   struct SemaphoreWaitInfo;
353   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
354   struct SemaphoreSignalInfo;
355   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
356   struct PhysicalDeviceBufferDeviceAddressFeatures;
357   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
358   struct BufferDeviceAddressInfo;
359   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
360   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
361   struct BufferOpaqueCaptureAddressCreateInfo;
362   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
363   struct MemoryOpaqueCaptureAddressAllocateInfo;
364   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
365   struct DeviceMemoryOpaqueCaptureAddressInfo;
366   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
367 
368   //=== VK_VERSION_1_3 ===
369   struct PhysicalDeviceVulkan13Features;
370   struct PhysicalDeviceVulkan13Properties;
371   struct PipelineCreationFeedbackCreateInfo;
372   using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
373   struct PipelineCreationFeedback;
374   using PipelineCreationFeedbackEXT = PipelineCreationFeedback;
375   struct PhysicalDeviceShaderTerminateInvocationFeatures;
376   using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures;
377   struct PhysicalDeviceToolProperties;
378   using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
379   struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
380   using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
381   struct PhysicalDevicePrivateDataFeatures;
382   using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
383   struct DevicePrivateDataCreateInfo;
384   using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
385   struct PrivateDataSlotCreateInfo;
386   using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
387   struct PhysicalDevicePipelineCreationCacheControlFeatures;
388   using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures;
389   struct MemoryBarrier2;
390   using MemoryBarrier2KHR = MemoryBarrier2;
391   struct BufferMemoryBarrier2;
392   using BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
393   struct ImageMemoryBarrier2;
394   using ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
395   struct DependencyInfo;
396   using DependencyInfoKHR = DependencyInfo;
397   struct SubmitInfo2;
398   using SubmitInfo2KHR = SubmitInfo2;
399   struct SemaphoreSubmitInfo;
400   using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
401   struct CommandBufferSubmitInfo;
402   using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
403   struct PhysicalDeviceSynchronization2Features;
404   using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
405   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
406   using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
407   struct PhysicalDeviceImageRobustnessFeatures;
408   using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
409   struct CopyBufferInfo2;
410   using CopyBufferInfo2KHR = CopyBufferInfo2;
411   struct CopyImageInfo2;
412   using CopyImageInfo2KHR = CopyImageInfo2;
413   struct CopyBufferToImageInfo2;
414   using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
415   struct CopyImageToBufferInfo2;
416   using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
417   struct BlitImageInfo2;
418   using BlitImageInfo2KHR = BlitImageInfo2;
419   struct ResolveImageInfo2;
420   using ResolveImageInfo2KHR = ResolveImageInfo2;
421   struct BufferCopy2;
422   using BufferCopy2KHR = BufferCopy2;
423   struct ImageCopy2;
424   using ImageCopy2KHR = ImageCopy2;
425   struct ImageBlit2;
426   using ImageBlit2KHR = ImageBlit2;
427   struct BufferImageCopy2;
428   using BufferImageCopy2KHR = BufferImageCopy2;
429   struct ImageResolve2;
430   using ImageResolve2KHR = ImageResolve2;
431   struct PhysicalDeviceSubgroupSizeControlFeatures;
432   using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
433   struct PhysicalDeviceSubgroupSizeControlProperties;
434   using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties;
435   struct PipelineShaderStageRequiredSubgroupSizeCreateInfo;
436   using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
437   struct PhysicalDeviceInlineUniformBlockFeatures;
438   using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
439   struct PhysicalDeviceInlineUniformBlockProperties;
440   using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
441   struct WriteDescriptorSetInlineUniformBlock;
442   using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
443   struct DescriptorPoolInlineUniformBlockCreateInfo;
444   using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
445   struct PhysicalDeviceTextureCompressionASTCHDRFeatures;
446   using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
447   struct RenderingInfo;
448   using RenderingInfoKHR = RenderingInfo;
449   struct RenderingAttachmentInfo;
450   using RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
451   struct PipelineRenderingCreateInfo;
452   using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
453   struct PhysicalDeviceDynamicRenderingFeatures;
454   using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
455   struct CommandBufferInheritanceRenderingInfo;
456   using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
457   struct PhysicalDeviceShaderIntegerDotProductFeatures;
458   using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures;
459   struct PhysicalDeviceShaderIntegerDotProductProperties;
460   using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties;
461   struct PhysicalDeviceTexelBufferAlignmentProperties;
462   using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties;
463   struct FormatProperties3;
464   using FormatProperties3KHR = FormatProperties3;
465   struct PhysicalDeviceMaintenance4Features;
466   using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
467   struct PhysicalDeviceMaintenance4Properties;
468   using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
469   struct DeviceBufferMemoryRequirements;
470   using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
471   struct DeviceImageMemoryRequirements;
472   using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
473 
474   //=== VK_KHR_surface ===
475   struct SurfaceCapabilitiesKHR;
476   struct SurfaceFormatKHR;
477 
478   //=== VK_KHR_swapchain ===
479   struct SwapchainCreateInfoKHR;
480   struct PresentInfoKHR;
481   struct ImageSwapchainCreateInfoKHR;
482   struct BindImageMemorySwapchainInfoKHR;
483   struct AcquireNextImageInfoKHR;
484   struct DeviceGroupPresentCapabilitiesKHR;
485   struct DeviceGroupPresentInfoKHR;
486   struct DeviceGroupSwapchainCreateInfoKHR;
487 
488   //=== VK_KHR_display ===
489   struct DisplayModeCreateInfoKHR;
490   struct DisplayModeParametersKHR;
491   struct DisplayModePropertiesKHR;
492   struct DisplayPlaneCapabilitiesKHR;
493   struct DisplayPlanePropertiesKHR;
494   struct DisplayPropertiesKHR;
495   struct DisplaySurfaceCreateInfoKHR;
496 
497   //=== VK_KHR_display_swapchain ===
498   struct DisplayPresentInfoKHR;
499 
500 #if defined( VK_USE_PLATFORM_XLIB_KHR )
501   //=== VK_KHR_xlib_surface ===
502   struct XlibSurfaceCreateInfoKHR;
503 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
504 
505 #if defined( VK_USE_PLATFORM_XCB_KHR )
506   //=== VK_KHR_xcb_surface ===
507   struct XcbSurfaceCreateInfoKHR;
508 #endif /*VK_USE_PLATFORM_XCB_KHR*/
509 
510 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
511   //=== VK_KHR_wayland_surface ===
512   struct WaylandSurfaceCreateInfoKHR;
513 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
514 
515 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
516   //=== VK_KHR_android_surface ===
517   struct AndroidSurfaceCreateInfoKHR;
518 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
519 
520 #if defined( VK_USE_PLATFORM_WIN32_KHR )
521   //=== VK_KHR_win32_surface ===
522   struct Win32SurfaceCreateInfoKHR;
523 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
524 
525   //=== VK_EXT_debug_report ===
526   struct DebugReportCallbackCreateInfoEXT;
527 
528   //=== VK_AMD_rasterization_order ===
529   struct PipelineRasterizationStateRasterizationOrderAMD;
530 
531   //=== VK_EXT_debug_marker ===
532   struct DebugMarkerObjectNameInfoEXT;
533   struct DebugMarkerObjectTagInfoEXT;
534   struct DebugMarkerMarkerInfoEXT;
535 
536   //=== VK_KHR_video_queue ===
537   struct QueueFamilyQueryResultStatusPropertiesKHR;
538   struct QueueFamilyVideoPropertiesKHR;
539   struct VideoProfileInfoKHR;
540   struct VideoProfileListInfoKHR;
541   struct VideoCapabilitiesKHR;
542   struct PhysicalDeviceVideoFormatInfoKHR;
543   struct VideoFormatPropertiesKHR;
544   struct VideoPictureResourceInfoKHR;
545   struct VideoReferenceSlotInfoKHR;
546   struct VideoSessionMemoryRequirementsKHR;
547   struct BindVideoSessionMemoryInfoKHR;
548   struct VideoSessionCreateInfoKHR;
549   struct VideoSessionParametersCreateInfoKHR;
550   struct VideoSessionParametersUpdateInfoKHR;
551   struct VideoBeginCodingInfoKHR;
552   struct VideoEndCodingInfoKHR;
553   struct VideoCodingControlInfoKHR;
554 
555   //=== VK_KHR_video_decode_queue ===
556   struct VideoDecodeCapabilitiesKHR;
557   struct VideoDecodeUsageInfoKHR;
558   struct VideoDecodeInfoKHR;
559 
560   //=== VK_NV_dedicated_allocation ===
561   struct DedicatedAllocationImageCreateInfoNV;
562   struct DedicatedAllocationBufferCreateInfoNV;
563   struct DedicatedAllocationMemoryAllocateInfoNV;
564 
565   //=== VK_EXT_transform_feedback ===
566   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
567   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
568   struct PipelineRasterizationStateStreamCreateInfoEXT;
569 
570   //=== VK_NVX_binary_import ===
571   struct CuModuleCreateInfoNVX;
572   struct CuFunctionCreateInfoNVX;
573   struct CuLaunchInfoNVX;
574 
575   //=== VK_NVX_image_view_handle ===
576   struct ImageViewHandleInfoNVX;
577   struct ImageViewAddressPropertiesNVX;
578 
579 #if defined( VK_ENABLE_BETA_EXTENSIONS )
580   //=== VK_EXT_video_encode_h264 ===
581   struct VideoEncodeH264CapabilitiesEXT;
582   struct VideoEncodeH264SessionParametersCreateInfoEXT;
583   struct VideoEncodeH264SessionParametersAddInfoEXT;
584   struct VideoEncodeH264VclFrameInfoEXT;
585   struct VideoEncodeH264ReferenceListsInfoEXT;
586   struct VideoEncodeH264EmitPictureParametersInfoEXT;
587   struct VideoEncodeH264DpbSlotInfoEXT;
588   struct VideoEncodeH264NaluSliceInfoEXT;
589   struct VideoEncodeH264ProfileInfoEXT;
590   struct VideoEncodeH264RateControlInfoEXT;
591   struct VideoEncodeH264RateControlLayerInfoEXT;
592   struct VideoEncodeH264QpEXT;
593   struct VideoEncodeH264FrameSizeEXT;
594 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
595 
596 #if defined( VK_ENABLE_BETA_EXTENSIONS )
597   //=== VK_EXT_video_encode_h265 ===
598   struct VideoEncodeH265CapabilitiesEXT;
599   struct VideoEncodeH265SessionParametersCreateInfoEXT;
600   struct VideoEncodeH265SessionParametersAddInfoEXT;
601   struct VideoEncodeH265VclFrameInfoEXT;
602   struct VideoEncodeH265EmitPictureParametersInfoEXT;
603   struct VideoEncodeH265DpbSlotInfoEXT;
604   struct VideoEncodeH265NaluSliceSegmentInfoEXT;
605   struct VideoEncodeH265ProfileInfoEXT;
606   struct VideoEncodeH265ReferenceListsInfoEXT;
607   struct VideoEncodeH265RateControlInfoEXT;
608   struct VideoEncodeH265RateControlLayerInfoEXT;
609   struct VideoEncodeH265QpEXT;
610   struct VideoEncodeH265FrameSizeEXT;
611 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
612 
613   //=== VK_KHR_video_decode_h264 ===
614   struct VideoDecodeH264ProfileInfoKHR;
615   struct VideoDecodeH264CapabilitiesKHR;
616   struct VideoDecodeH264SessionParametersCreateInfoKHR;
617   struct VideoDecodeH264SessionParametersAddInfoKHR;
618   struct VideoDecodeH264PictureInfoKHR;
619   struct VideoDecodeH264DpbSlotInfoKHR;
620 
621   //=== VK_AMD_texture_gather_bias_lod ===
622   struct TextureLODGatherFormatPropertiesAMD;
623 
624   //=== VK_AMD_shader_info ===
625   struct ShaderResourceUsageAMD;
626   struct ShaderStatisticsInfoAMD;
627 
628   //=== VK_KHR_dynamic_rendering ===
629   struct RenderingFragmentShadingRateAttachmentInfoKHR;
630   struct RenderingFragmentDensityMapAttachmentInfoEXT;
631   struct AttachmentSampleCountInfoAMD;
632   using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
633   struct MultiviewPerViewAttributesInfoNVX;
634 
635 #if defined( VK_USE_PLATFORM_GGP )
636   //=== VK_GGP_stream_descriptor_surface ===
637   struct StreamDescriptorSurfaceCreateInfoGGP;
638 #endif /*VK_USE_PLATFORM_GGP*/
639 
640   //=== VK_NV_corner_sampled_image ===
641   struct PhysicalDeviceCornerSampledImageFeaturesNV;
642 
643   //=== VK_NV_external_memory_capabilities ===
644   struct ExternalImageFormatPropertiesNV;
645 
646   //=== VK_NV_external_memory ===
647   struct ExternalMemoryImageCreateInfoNV;
648   struct ExportMemoryAllocateInfoNV;
649 
650 #if defined( VK_USE_PLATFORM_WIN32_KHR )
651   //=== VK_NV_external_memory_win32 ===
652   struct ImportMemoryWin32HandleInfoNV;
653   struct ExportMemoryWin32HandleInfoNV;
654 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
655 
656 #if defined( VK_USE_PLATFORM_WIN32_KHR )
657   //=== VK_NV_win32_keyed_mutex ===
658   struct Win32KeyedMutexAcquireReleaseInfoNV;
659 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
660 
661   //=== VK_EXT_validation_flags ===
662   struct ValidationFlagsEXT;
663 
664 #if defined( VK_USE_PLATFORM_VI_NN )
665   //=== VK_NN_vi_surface ===
666   struct ViSurfaceCreateInfoNN;
667 #endif /*VK_USE_PLATFORM_VI_NN*/
668 
669   //=== VK_EXT_astc_decode_mode ===
670   struct ImageViewASTCDecodeModeEXT;
671   struct PhysicalDeviceASTCDecodeFeaturesEXT;
672 
673   //=== VK_EXT_pipeline_robustness ===
674   struct PhysicalDevicePipelineRobustnessFeaturesEXT;
675   struct PhysicalDevicePipelineRobustnessPropertiesEXT;
676   struct PipelineRobustnessCreateInfoEXT;
677 
678 #if defined( VK_USE_PLATFORM_WIN32_KHR )
679   //=== VK_KHR_external_memory_win32 ===
680   struct ImportMemoryWin32HandleInfoKHR;
681   struct ExportMemoryWin32HandleInfoKHR;
682   struct MemoryWin32HandlePropertiesKHR;
683   struct MemoryGetWin32HandleInfoKHR;
684 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
685 
686   //=== VK_KHR_external_memory_fd ===
687   struct ImportMemoryFdInfoKHR;
688   struct MemoryFdPropertiesKHR;
689   struct MemoryGetFdInfoKHR;
690 
691 #if defined( VK_USE_PLATFORM_WIN32_KHR )
692   //=== VK_KHR_win32_keyed_mutex ===
693   struct Win32KeyedMutexAcquireReleaseInfoKHR;
694 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
695 
696 #if defined( VK_USE_PLATFORM_WIN32_KHR )
697   //=== VK_KHR_external_semaphore_win32 ===
698   struct ImportSemaphoreWin32HandleInfoKHR;
699   struct ExportSemaphoreWin32HandleInfoKHR;
700   struct D3D12FenceSubmitInfoKHR;
701   struct SemaphoreGetWin32HandleInfoKHR;
702 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
703 
704   //=== VK_KHR_external_semaphore_fd ===
705   struct ImportSemaphoreFdInfoKHR;
706   struct SemaphoreGetFdInfoKHR;
707 
708   //=== VK_KHR_push_descriptor ===
709   struct PhysicalDevicePushDescriptorPropertiesKHR;
710 
711   //=== VK_EXT_conditional_rendering ===
712   struct ConditionalRenderingBeginInfoEXT;
713   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
714   struct CommandBufferInheritanceConditionalRenderingInfoEXT;
715 
716   //=== VK_KHR_incremental_present ===
717   struct PresentRegionsKHR;
718   struct PresentRegionKHR;
719   struct RectLayerKHR;
720 
721   //=== VK_NV_clip_space_w_scaling ===
722   struct ViewportWScalingNV;
723   struct PipelineViewportWScalingStateCreateInfoNV;
724 
725   //=== VK_EXT_display_surface_counter ===
726   struct SurfaceCapabilities2EXT;
727 
728   //=== VK_EXT_display_control ===
729   struct DisplayPowerInfoEXT;
730   struct DeviceEventInfoEXT;
731   struct DisplayEventInfoEXT;
732   struct SwapchainCounterCreateInfoEXT;
733 
734   //=== VK_GOOGLE_display_timing ===
735   struct RefreshCycleDurationGOOGLE;
736   struct PastPresentationTimingGOOGLE;
737   struct PresentTimesInfoGOOGLE;
738   struct PresentTimeGOOGLE;
739 
740   //=== VK_NVX_multiview_per_view_attributes ===
741   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
742 
743   //=== VK_NV_viewport_swizzle ===
744   struct ViewportSwizzleNV;
745   struct PipelineViewportSwizzleStateCreateInfoNV;
746 
747   //=== VK_EXT_discard_rectangles ===
748   struct PhysicalDeviceDiscardRectanglePropertiesEXT;
749   struct PipelineDiscardRectangleStateCreateInfoEXT;
750 
751   //=== VK_EXT_conservative_rasterization ===
752   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
753   struct PipelineRasterizationConservativeStateCreateInfoEXT;
754 
755   //=== VK_EXT_depth_clip_enable ===
756   struct PhysicalDeviceDepthClipEnableFeaturesEXT;
757   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
758 
759   //=== VK_EXT_hdr_metadata ===
760   struct HdrMetadataEXT;
761   struct XYColorEXT;
762 
763   //=== VK_KHR_shared_presentable_image ===
764   struct SharedPresentSurfaceCapabilitiesKHR;
765 
766 #if defined( VK_USE_PLATFORM_WIN32_KHR )
767   //=== VK_KHR_external_fence_win32 ===
768   struct ImportFenceWin32HandleInfoKHR;
769   struct ExportFenceWin32HandleInfoKHR;
770   struct FenceGetWin32HandleInfoKHR;
771 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
772 
773   //=== VK_KHR_external_fence_fd ===
774   struct ImportFenceFdInfoKHR;
775   struct FenceGetFdInfoKHR;
776 
777   //=== VK_KHR_performance_query ===
778   struct PhysicalDevicePerformanceQueryFeaturesKHR;
779   struct PhysicalDevicePerformanceQueryPropertiesKHR;
780   struct PerformanceCounterKHR;
781   struct PerformanceCounterDescriptionKHR;
782   struct QueryPoolPerformanceCreateInfoKHR;
783   union PerformanceCounterResultKHR;
784   struct AcquireProfilingLockInfoKHR;
785   struct PerformanceQuerySubmitInfoKHR;
786 
787   //=== VK_KHR_get_surface_capabilities2 ===
788   struct PhysicalDeviceSurfaceInfo2KHR;
789   struct SurfaceCapabilities2KHR;
790   struct SurfaceFormat2KHR;
791 
792   //=== VK_KHR_get_display_properties2 ===
793   struct DisplayProperties2KHR;
794   struct DisplayPlaneProperties2KHR;
795   struct DisplayModeProperties2KHR;
796   struct DisplayPlaneInfo2KHR;
797   struct DisplayPlaneCapabilities2KHR;
798 
799 #if defined( VK_USE_PLATFORM_IOS_MVK )
800   //=== VK_MVK_ios_surface ===
801   struct IOSSurfaceCreateInfoMVK;
802 #endif /*VK_USE_PLATFORM_IOS_MVK*/
803 
804 #if defined( VK_USE_PLATFORM_MACOS_MVK )
805   //=== VK_MVK_macos_surface ===
806   struct MacOSSurfaceCreateInfoMVK;
807 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
808 
809   //=== VK_EXT_debug_utils ===
810   struct DebugUtilsLabelEXT;
811   struct DebugUtilsMessengerCallbackDataEXT;
812   struct DebugUtilsMessengerCreateInfoEXT;
813   struct DebugUtilsObjectNameInfoEXT;
814   struct DebugUtilsObjectTagInfoEXT;
815 
816 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
817   //=== VK_ANDROID_external_memory_android_hardware_buffer ===
818   struct AndroidHardwareBufferUsageANDROID;
819   struct AndroidHardwareBufferPropertiesANDROID;
820   struct AndroidHardwareBufferFormatPropertiesANDROID;
821   struct ImportAndroidHardwareBufferInfoANDROID;
822   struct MemoryGetAndroidHardwareBufferInfoANDROID;
823   struct ExternalFormatANDROID;
824   struct AndroidHardwareBufferFormatProperties2ANDROID;
825 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
826 
827   //=== VK_EXT_sample_locations ===
828   struct SampleLocationEXT;
829   struct SampleLocationsInfoEXT;
830   struct AttachmentSampleLocationsEXT;
831   struct SubpassSampleLocationsEXT;
832   struct RenderPassSampleLocationsBeginInfoEXT;
833   struct PipelineSampleLocationsStateCreateInfoEXT;
834   struct PhysicalDeviceSampleLocationsPropertiesEXT;
835   struct MultisamplePropertiesEXT;
836 
837   //=== VK_EXT_blend_operation_advanced ===
838   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
839   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
840   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
841 
842   //=== VK_NV_fragment_coverage_to_color ===
843   struct PipelineCoverageToColorStateCreateInfoNV;
844 
845   //=== VK_KHR_acceleration_structure ===
846   union DeviceOrHostAddressKHR;
847   union DeviceOrHostAddressConstKHR;
848   struct AccelerationStructureBuildRangeInfoKHR;
849   struct AabbPositionsKHR;
850   using AabbPositionsNV = AabbPositionsKHR;
851   struct AccelerationStructureGeometryTrianglesDataKHR;
852   struct TransformMatrixKHR;
853   using TransformMatrixNV = TransformMatrixKHR;
854   struct AccelerationStructureBuildGeometryInfoKHR;
855   struct AccelerationStructureGeometryAabbsDataKHR;
856   struct AccelerationStructureInstanceKHR;
857   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
858   struct AccelerationStructureGeometryInstancesDataKHR;
859   union AccelerationStructureGeometryDataKHR;
860   struct AccelerationStructureGeometryKHR;
861   struct AccelerationStructureCreateInfoKHR;
862   struct WriteDescriptorSetAccelerationStructureKHR;
863   struct PhysicalDeviceAccelerationStructureFeaturesKHR;
864   struct PhysicalDeviceAccelerationStructurePropertiesKHR;
865   struct AccelerationStructureDeviceAddressInfoKHR;
866   struct AccelerationStructureVersionInfoKHR;
867   struct CopyAccelerationStructureToMemoryInfoKHR;
868   struct CopyMemoryToAccelerationStructureInfoKHR;
869   struct CopyAccelerationStructureInfoKHR;
870   struct AccelerationStructureBuildSizesInfoKHR;
871 
872   //=== VK_NV_framebuffer_mixed_samples ===
873   struct PipelineCoverageModulationStateCreateInfoNV;
874 
875   //=== VK_NV_shader_sm_builtins ===
876   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
877   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
878 
879   //=== VK_EXT_image_drm_format_modifier ===
880   struct DrmFormatModifierPropertiesListEXT;
881   struct DrmFormatModifierPropertiesEXT;
882   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
883   struct ImageDrmFormatModifierListCreateInfoEXT;
884   struct ImageDrmFormatModifierExplicitCreateInfoEXT;
885   struct ImageDrmFormatModifierPropertiesEXT;
886   struct DrmFormatModifierPropertiesList2EXT;
887   struct DrmFormatModifierProperties2EXT;
888 
889   //=== VK_EXT_validation_cache ===
890   struct ValidationCacheCreateInfoEXT;
891   struct ShaderModuleValidationCacheCreateInfoEXT;
892 
893 #if defined( VK_ENABLE_BETA_EXTENSIONS )
894   //=== VK_KHR_portability_subset ===
895   struct PhysicalDevicePortabilitySubsetFeaturesKHR;
896   struct PhysicalDevicePortabilitySubsetPropertiesKHR;
897 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
898 
899   //=== VK_NV_shading_rate_image ===
900   struct ShadingRatePaletteNV;
901   struct PipelineViewportShadingRateImageStateCreateInfoNV;
902   struct PhysicalDeviceShadingRateImageFeaturesNV;
903   struct PhysicalDeviceShadingRateImagePropertiesNV;
904   struct CoarseSampleLocationNV;
905   struct CoarseSampleOrderCustomNV;
906   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
907 
908   //=== VK_NV_ray_tracing ===
909   struct RayTracingShaderGroupCreateInfoNV;
910   struct RayTracingPipelineCreateInfoNV;
911   struct GeometryTrianglesNV;
912   struct GeometryAABBNV;
913   struct GeometryDataNV;
914   struct GeometryNV;
915   struct AccelerationStructureInfoNV;
916   struct AccelerationStructureCreateInfoNV;
917   struct BindAccelerationStructureMemoryInfoNV;
918   struct WriteDescriptorSetAccelerationStructureNV;
919   struct AccelerationStructureMemoryRequirementsInfoNV;
920   struct PhysicalDeviceRayTracingPropertiesNV;
921 
922   //=== VK_NV_representative_fragment_test ===
923   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
924   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
925 
926   //=== VK_EXT_filter_cubic ===
927   struct PhysicalDeviceImageViewImageFormatInfoEXT;
928   struct FilterCubicImageViewImageFormatPropertiesEXT;
929 
930   //=== VK_EXT_external_memory_host ===
931   struct ImportMemoryHostPointerInfoEXT;
932   struct MemoryHostPointerPropertiesEXT;
933   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
934 
935   //=== VK_KHR_shader_clock ===
936   struct PhysicalDeviceShaderClockFeaturesKHR;
937 
938   //=== VK_AMD_pipeline_compiler_control ===
939   struct PipelineCompilerControlCreateInfoAMD;
940 
941   //=== VK_EXT_calibrated_timestamps ===
942   struct CalibratedTimestampInfoEXT;
943 
944   //=== VK_AMD_shader_core_properties ===
945   struct PhysicalDeviceShaderCorePropertiesAMD;
946 
947   //=== VK_KHR_video_decode_h265 ===
948   struct VideoDecodeH265ProfileInfoKHR;
949   struct VideoDecodeH265CapabilitiesKHR;
950   struct VideoDecodeH265SessionParametersCreateInfoKHR;
951   struct VideoDecodeH265SessionParametersAddInfoKHR;
952   struct VideoDecodeH265PictureInfoKHR;
953   struct VideoDecodeH265DpbSlotInfoKHR;
954 
955   //=== VK_KHR_global_priority ===
956   struct DeviceQueueGlobalPriorityCreateInfoKHR;
957   using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;
958   struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
959   using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
960   struct QueueFamilyGlobalPriorityPropertiesKHR;
961   using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;
962 
963   //=== VK_AMD_memory_overallocation_behavior ===
964   struct DeviceMemoryOverallocationCreateInfoAMD;
965 
966   //=== VK_EXT_vertex_attribute_divisor ===
967   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
968   struct VertexInputBindingDivisorDescriptionEXT;
969   struct PipelineVertexInputDivisorStateCreateInfoEXT;
970   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
971 
972 #if defined( VK_USE_PLATFORM_GGP )
973   //=== VK_GGP_frame_token ===
974   struct PresentFrameTokenGGP;
975 #endif /*VK_USE_PLATFORM_GGP*/
976 
977   //=== VK_NV_compute_shader_derivatives ===
978   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
979 
980   //=== VK_NV_mesh_shader ===
981   struct PhysicalDeviceMeshShaderFeaturesNV;
982   struct PhysicalDeviceMeshShaderPropertiesNV;
983   struct DrawMeshTasksIndirectCommandNV;
984 
985   //=== VK_NV_shader_image_footprint ===
986   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
987 
988   //=== VK_NV_scissor_exclusive ===
989   struct PipelineViewportExclusiveScissorStateCreateInfoNV;
990   struct PhysicalDeviceExclusiveScissorFeaturesNV;
991 
992   //=== VK_NV_device_diagnostic_checkpoints ===
993   struct QueueFamilyCheckpointPropertiesNV;
994   struct CheckpointDataNV;
995 
996   //=== VK_INTEL_shader_integer_functions2 ===
997   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
998 
999   //=== VK_INTEL_performance_query ===
1000   union PerformanceValueDataINTEL;
1001   struct PerformanceValueINTEL;
1002   struct InitializePerformanceApiInfoINTEL;
1003   struct QueryPoolPerformanceQueryCreateInfoINTEL;
1004   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
1005   struct PerformanceMarkerInfoINTEL;
1006   struct PerformanceStreamMarkerInfoINTEL;
1007   struct PerformanceOverrideInfoINTEL;
1008   struct PerformanceConfigurationAcquireInfoINTEL;
1009 
1010   //=== VK_EXT_pci_bus_info ===
1011   struct PhysicalDevicePCIBusInfoPropertiesEXT;
1012 
1013   //=== VK_AMD_display_native_hdr ===
1014   struct DisplayNativeHdrSurfaceCapabilitiesAMD;
1015   struct SwapchainDisplayNativeHdrCreateInfoAMD;
1016 
1017 #if defined( VK_USE_PLATFORM_FUCHSIA )
1018   //=== VK_FUCHSIA_imagepipe_surface ===
1019   struct ImagePipeSurfaceCreateInfoFUCHSIA;
1020 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1021 
1022 #if defined( VK_USE_PLATFORM_METAL_EXT )
1023   //=== VK_EXT_metal_surface ===
1024   struct MetalSurfaceCreateInfoEXT;
1025 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1026 
1027   //=== VK_EXT_fragment_density_map ===
1028   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
1029   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
1030   struct RenderPassFragmentDensityMapCreateInfoEXT;
1031 
1032   //=== VK_KHR_fragment_shading_rate ===
1033   struct FragmentShadingRateAttachmentInfoKHR;
1034   struct PipelineFragmentShadingRateStateCreateInfoKHR;
1035   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
1036   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
1037   struct PhysicalDeviceFragmentShadingRateKHR;
1038 
1039   //=== VK_AMD_shader_core_properties2 ===
1040   struct PhysicalDeviceShaderCoreProperties2AMD;
1041 
1042   //=== VK_AMD_device_coherent_memory ===
1043   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
1044 
1045   //=== VK_EXT_shader_image_atomic_int64 ===
1046   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
1047 
1048   //=== VK_EXT_memory_budget ===
1049   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
1050 
1051   //=== VK_EXT_memory_priority ===
1052   struct PhysicalDeviceMemoryPriorityFeaturesEXT;
1053   struct MemoryPriorityAllocateInfoEXT;
1054 
1055   //=== VK_KHR_surface_protected_capabilities ===
1056   struct SurfaceProtectedCapabilitiesKHR;
1057 
1058   //=== VK_NV_dedicated_allocation_image_aliasing ===
1059   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
1060 
1061   //=== VK_EXT_buffer_device_address ===
1062   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1063   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
1064   struct BufferDeviceAddressCreateInfoEXT;
1065 
1066   //=== VK_EXT_validation_features ===
1067   struct ValidationFeaturesEXT;
1068 
1069   //=== VK_KHR_present_wait ===
1070   struct PhysicalDevicePresentWaitFeaturesKHR;
1071 
1072   //=== VK_NV_cooperative_matrix ===
1073   struct CooperativeMatrixPropertiesNV;
1074   struct PhysicalDeviceCooperativeMatrixFeaturesNV;
1075   struct PhysicalDeviceCooperativeMatrixPropertiesNV;
1076 
1077   //=== VK_NV_coverage_reduction_mode ===
1078   struct PhysicalDeviceCoverageReductionModeFeaturesNV;
1079   struct PipelineCoverageReductionStateCreateInfoNV;
1080   struct FramebufferMixedSamplesCombinationNV;
1081 
1082   //=== VK_EXT_fragment_shader_interlock ===
1083   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
1084 
1085   //=== VK_EXT_ycbcr_image_arrays ===
1086   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
1087 
1088   //=== VK_EXT_provoking_vertex ===
1089   struct PhysicalDeviceProvokingVertexFeaturesEXT;
1090   struct PhysicalDeviceProvokingVertexPropertiesEXT;
1091   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
1092 
1093 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1094   //=== VK_EXT_full_screen_exclusive ===
1095   struct SurfaceFullScreenExclusiveInfoEXT;
1096   struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1097   struct SurfaceFullScreenExclusiveWin32InfoEXT;
1098 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1099 
1100   //=== VK_EXT_headless_surface ===
1101   struct HeadlessSurfaceCreateInfoEXT;
1102 
1103   //=== VK_EXT_line_rasterization ===
1104   struct PhysicalDeviceLineRasterizationFeaturesEXT;
1105   struct PhysicalDeviceLineRasterizationPropertiesEXT;
1106   struct PipelineRasterizationLineStateCreateInfoEXT;
1107 
1108   //=== VK_EXT_shader_atomic_float ===
1109   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
1110 
1111   //=== VK_EXT_index_type_uint8 ===
1112   struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
1113 
1114   //=== VK_EXT_extended_dynamic_state ===
1115   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
1116 
1117   //=== VK_KHR_pipeline_executable_properties ===
1118   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
1119   struct PipelineInfoKHR;
1120   using PipelineInfoEXT = PipelineInfoKHR;
1121   struct PipelineExecutablePropertiesKHR;
1122   struct PipelineExecutableInfoKHR;
1123   union PipelineExecutableStatisticValueKHR;
1124   struct PipelineExecutableStatisticKHR;
1125   struct PipelineExecutableInternalRepresentationKHR;
1126 
1127   //=== VK_EXT_shader_atomic_float2 ===
1128   struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
1129 
1130   //=== VK_EXT_surface_maintenance1 ===
1131   struct SurfacePresentModeEXT;
1132   struct SurfacePresentScalingCapabilitiesEXT;
1133   struct SurfacePresentModeCompatibilityEXT;
1134 
1135   //=== VK_EXT_swapchain_maintenance1 ===
1136   struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
1137   struct SwapchainPresentFenceInfoEXT;
1138   struct SwapchainPresentModesCreateInfoEXT;
1139   struct SwapchainPresentModeInfoEXT;
1140   struct SwapchainPresentScalingCreateInfoEXT;
1141   struct ReleaseSwapchainImagesInfoEXT;
1142 
1143   //=== VK_NV_device_generated_commands ===
1144   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
1145   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
1146   struct GraphicsShaderGroupCreateInfoNV;
1147   struct GraphicsPipelineShaderGroupsCreateInfoNV;
1148   struct BindShaderGroupIndirectCommandNV;
1149   struct BindIndexBufferIndirectCommandNV;
1150   struct BindVertexBufferIndirectCommandNV;
1151   struct SetStateFlagsIndirectCommandNV;
1152   struct IndirectCommandsStreamNV;
1153   struct IndirectCommandsLayoutTokenNV;
1154   struct IndirectCommandsLayoutCreateInfoNV;
1155   struct GeneratedCommandsInfoNV;
1156   struct GeneratedCommandsMemoryRequirementsInfoNV;
1157 
1158   //=== VK_NV_inherited_viewport_scissor ===
1159   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
1160   struct CommandBufferInheritanceViewportScissorInfoNV;
1161 
1162   //=== VK_EXT_texel_buffer_alignment ===
1163   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
1164 
1165   //=== VK_QCOM_render_pass_transform ===
1166   struct RenderPassTransformBeginInfoQCOM;
1167   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
1168 
1169   //=== VK_EXT_device_memory_report ===
1170   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
1171   struct DeviceDeviceMemoryReportCreateInfoEXT;
1172   struct DeviceMemoryReportCallbackDataEXT;
1173 
1174   //=== VK_EXT_robustness2 ===
1175   struct PhysicalDeviceRobustness2FeaturesEXT;
1176   struct PhysicalDeviceRobustness2PropertiesEXT;
1177 
1178   //=== VK_EXT_custom_border_color ===
1179   struct SamplerCustomBorderColorCreateInfoEXT;
1180   struct PhysicalDeviceCustomBorderColorPropertiesEXT;
1181   struct PhysicalDeviceCustomBorderColorFeaturesEXT;
1182 
1183   //=== VK_KHR_pipeline_library ===
1184   struct PipelineLibraryCreateInfoKHR;
1185 
1186   //=== VK_NV_present_barrier ===
1187   struct PhysicalDevicePresentBarrierFeaturesNV;
1188   struct SurfaceCapabilitiesPresentBarrierNV;
1189   struct SwapchainPresentBarrierCreateInfoNV;
1190 
1191   //=== VK_KHR_present_id ===
1192   struct PresentIdKHR;
1193   struct PhysicalDevicePresentIdFeaturesKHR;
1194 
1195 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1196   //=== VK_KHR_video_encode_queue ===
1197   struct VideoEncodeInfoKHR;
1198   struct VideoEncodeCapabilitiesKHR;
1199   struct VideoEncodeUsageInfoKHR;
1200   struct VideoEncodeRateControlInfoKHR;
1201   struct VideoEncodeRateControlLayerInfoKHR;
1202 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1203 
1204   //=== VK_NV_device_diagnostics_config ===
1205   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
1206   struct DeviceDiagnosticsConfigCreateInfoNV;
1207 
1208 #if defined( VK_USE_PLATFORM_METAL_EXT )
1209   //=== VK_EXT_metal_objects ===
1210   struct ExportMetalObjectCreateInfoEXT;
1211   struct ExportMetalObjectsInfoEXT;
1212   struct ExportMetalDeviceInfoEXT;
1213   struct ExportMetalCommandQueueInfoEXT;
1214   struct ExportMetalBufferInfoEXT;
1215   struct ImportMetalBufferInfoEXT;
1216   struct ExportMetalTextureInfoEXT;
1217   struct ImportMetalTextureInfoEXT;
1218   struct ExportMetalIOSurfaceInfoEXT;
1219   struct ImportMetalIOSurfaceInfoEXT;
1220   struct ExportMetalSharedEventInfoEXT;
1221   struct ImportMetalSharedEventInfoEXT;
1222 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1223 
1224   //=== VK_KHR_synchronization2 ===
1225   struct QueueFamilyCheckpointProperties2NV;
1226   struct CheckpointData2NV;
1227 
1228   //=== VK_EXT_descriptor_buffer ===
1229   struct PhysicalDeviceDescriptorBufferPropertiesEXT;
1230   struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
1231   struct PhysicalDeviceDescriptorBufferFeaturesEXT;
1232   struct DescriptorAddressInfoEXT;
1233   struct DescriptorBufferBindingInfoEXT;
1234   struct DescriptorBufferBindingPushDescriptorBufferHandleEXT;
1235   union DescriptorDataEXT;
1236   struct DescriptorGetInfoEXT;
1237   struct BufferCaptureDescriptorDataInfoEXT;
1238   struct ImageCaptureDescriptorDataInfoEXT;
1239   struct ImageViewCaptureDescriptorDataInfoEXT;
1240   struct SamplerCaptureDescriptorDataInfoEXT;
1241   struct OpaqueCaptureDescriptorDataCreateInfoEXT;
1242   struct AccelerationStructureCaptureDescriptorDataInfoEXT;
1243 
1244   //=== VK_EXT_graphics_pipeline_library ===
1245   struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
1246   struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
1247   struct GraphicsPipelineLibraryCreateInfoEXT;
1248 
1249   //=== VK_AMD_shader_early_and_late_fragment_tests ===
1250   struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
1251 
1252   //=== VK_KHR_fragment_shader_barycentric ===
1253   struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1254   using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
1255   struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
1256 
1257   //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1258   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
1259 
1260   //=== VK_NV_fragment_shading_rate_enums ===
1261   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
1262   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
1263   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
1264 
1265   //=== VK_NV_ray_tracing_motion_blur ===
1266   struct AccelerationStructureGeometryMotionTrianglesDataNV;
1267   struct AccelerationStructureMotionInfoNV;
1268   struct AccelerationStructureMotionInstanceNV;
1269   union AccelerationStructureMotionInstanceDataNV;
1270   struct AccelerationStructureMatrixMotionInstanceNV;
1271   struct AccelerationStructureSRTMotionInstanceNV;
1272   struct SRTDataNV;
1273   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
1274 
1275   //=== VK_EXT_mesh_shader ===
1276   struct PhysicalDeviceMeshShaderFeaturesEXT;
1277   struct PhysicalDeviceMeshShaderPropertiesEXT;
1278   struct DrawMeshTasksIndirectCommandEXT;
1279 
1280   //=== VK_EXT_ycbcr_2plane_444_formats ===
1281   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
1282 
1283   //=== VK_EXT_fragment_density_map2 ===
1284   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
1285   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
1286 
1287   //=== VK_QCOM_rotated_copy_commands ===
1288   struct CopyCommandTransformInfoQCOM;
1289 
1290   //=== VK_KHR_workgroup_memory_explicit_layout ===
1291   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
1292 
1293   //=== VK_EXT_image_compression_control ===
1294   struct PhysicalDeviceImageCompressionControlFeaturesEXT;
1295   struct ImageCompressionControlEXT;
1296   struct SubresourceLayout2EXT;
1297   struct ImageSubresource2EXT;
1298   struct ImageCompressionPropertiesEXT;
1299 
1300   //=== VK_EXT_attachment_feedback_loop_layout ===
1301   struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
1302 
1303   //=== VK_EXT_4444_formats ===
1304   struct PhysicalDevice4444FormatsFeaturesEXT;
1305 
1306   //=== VK_EXT_device_fault ===
1307   struct PhysicalDeviceFaultFeaturesEXT;
1308   struct DeviceFaultCountsEXT;
1309   struct DeviceFaultInfoEXT;
1310   struct DeviceFaultAddressInfoEXT;
1311   struct DeviceFaultVendorInfoEXT;
1312   struct DeviceFaultVendorBinaryHeaderVersionOneEXT;
1313 
1314   //=== VK_EXT_rgba10x6_formats ===
1315   struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
1316 
1317 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1318   //=== VK_EXT_directfb_surface ===
1319   struct DirectFBSurfaceCreateInfoEXT;
1320 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1321 
1322   //=== VK_KHR_ray_tracing_pipeline ===
1323   struct RayTracingShaderGroupCreateInfoKHR;
1324   struct RayTracingPipelineCreateInfoKHR;
1325   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
1326   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
1327   struct StridedDeviceAddressRegionKHR;
1328   struct TraceRaysIndirectCommandKHR;
1329   struct RayTracingPipelineInterfaceCreateInfoKHR;
1330 
1331   //=== VK_KHR_ray_query ===
1332   struct PhysicalDeviceRayQueryFeaturesKHR;
1333 
1334   //=== VK_EXT_vertex_input_dynamic_state ===
1335   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
1336   struct VertexInputBindingDescription2EXT;
1337   struct VertexInputAttributeDescription2EXT;
1338 
1339   //=== VK_EXT_physical_device_drm ===
1340   struct PhysicalDeviceDrmPropertiesEXT;
1341 
1342   //=== VK_EXT_device_address_binding_report ===
1343   struct PhysicalDeviceAddressBindingReportFeaturesEXT;
1344   struct DeviceAddressBindingCallbackDataEXT;
1345 
1346   //=== VK_EXT_depth_clip_control ===
1347   struct PhysicalDeviceDepthClipControlFeaturesEXT;
1348   struct PipelineViewportDepthClipControlCreateInfoEXT;
1349 
1350   //=== VK_EXT_primitive_topology_list_restart ===
1351   struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
1352 
1353 #if defined( VK_USE_PLATFORM_FUCHSIA )
1354   //=== VK_FUCHSIA_external_memory ===
1355   struct ImportMemoryZirconHandleInfoFUCHSIA;
1356   struct MemoryZirconHandlePropertiesFUCHSIA;
1357   struct MemoryGetZirconHandleInfoFUCHSIA;
1358 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1359 
1360 #if defined( VK_USE_PLATFORM_FUCHSIA )
1361   //=== VK_FUCHSIA_external_semaphore ===
1362   struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1363   struct SemaphoreGetZirconHandleInfoFUCHSIA;
1364 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1365 
1366 #if defined( VK_USE_PLATFORM_FUCHSIA )
1367   //=== VK_FUCHSIA_buffer_collection ===
1368   struct BufferCollectionCreateInfoFUCHSIA;
1369   struct ImportMemoryBufferCollectionFUCHSIA;
1370   struct BufferCollectionImageCreateInfoFUCHSIA;
1371   struct BufferConstraintsInfoFUCHSIA;
1372   struct BufferCollectionBufferCreateInfoFUCHSIA;
1373   struct BufferCollectionPropertiesFUCHSIA;
1374   struct SysmemColorSpaceFUCHSIA;
1375   struct ImageConstraintsInfoFUCHSIA;
1376   struct ImageFormatConstraintsInfoFUCHSIA;
1377   struct BufferCollectionConstraintsInfoFUCHSIA;
1378 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1379 
1380   //=== VK_HUAWEI_subpass_shading ===
1381   struct SubpassShadingPipelineCreateInfoHUAWEI;
1382   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
1383   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
1384 
1385   //=== VK_HUAWEI_invocation_mask ===
1386   struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
1387 
1388   //=== VK_NV_external_memory_rdma ===
1389   struct MemoryGetRemoteAddressInfoNV;
1390   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
1391 
1392   //=== VK_EXT_pipeline_properties ===
1393   struct PipelinePropertiesIdentifierEXT;
1394   struct PhysicalDevicePipelinePropertiesFeaturesEXT;
1395 
1396   //=== VK_EXT_multisampled_render_to_single_sampled ===
1397   struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
1398   struct SubpassResolvePerformanceQueryEXT;
1399   struct MultisampledRenderToSingleSampledInfoEXT;
1400 
1401   //=== VK_EXT_extended_dynamic_state2 ===
1402   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
1403 
1404 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1405   //=== VK_QNX_screen_surface ===
1406   struct ScreenSurfaceCreateInfoQNX;
1407 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1408 
1409   //=== VK_EXT_color_write_enable ===
1410   struct PhysicalDeviceColorWriteEnableFeaturesEXT;
1411   struct PipelineColorWriteCreateInfoEXT;
1412 
1413   //=== VK_EXT_primitives_generated_query ===
1414   struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
1415 
1416   //=== VK_KHR_ray_tracing_maintenance1 ===
1417   struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
1418   struct TraceRaysIndirectCommand2KHR;
1419 
1420   //=== VK_EXT_image_view_min_lod ===
1421   struct PhysicalDeviceImageViewMinLodFeaturesEXT;
1422   struct ImageViewMinLodCreateInfoEXT;
1423 
1424   //=== VK_EXT_multi_draw ===
1425   struct PhysicalDeviceMultiDrawFeaturesEXT;
1426   struct PhysicalDeviceMultiDrawPropertiesEXT;
1427   struct MultiDrawInfoEXT;
1428   struct MultiDrawIndexedInfoEXT;
1429 
1430   //=== VK_EXT_image_2d_view_of_3d ===
1431   struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
1432 
1433   //=== VK_EXT_opacity_micromap ===
1434   struct MicromapBuildInfoEXT;
1435   struct MicromapUsageEXT;
1436   struct MicromapCreateInfoEXT;
1437   struct PhysicalDeviceOpacityMicromapFeaturesEXT;
1438   struct PhysicalDeviceOpacityMicromapPropertiesEXT;
1439   struct MicromapVersionInfoEXT;
1440   struct CopyMicromapToMemoryInfoEXT;
1441   struct CopyMemoryToMicromapInfoEXT;
1442   struct CopyMicromapInfoEXT;
1443   struct MicromapBuildSizesInfoEXT;
1444   struct AccelerationStructureTrianglesOpacityMicromapEXT;
1445   struct MicromapTriangleEXT;
1446 
1447   //=== VK_HUAWEI_cluster_culling_shader ===
1448   struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
1449   struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
1450 
1451   //=== VK_EXT_border_color_swizzle ===
1452   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
1453   struct SamplerBorderColorComponentMappingCreateInfoEXT;
1454 
1455   //=== VK_EXT_pageable_device_local_memory ===
1456   struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
1457 
1458   //=== VK_VALVE_descriptor_set_host_mapping ===
1459   struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
1460   struct DescriptorSetBindingReferenceVALVE;
1461   struct DescriptorSetLayoutHostMappingInfoVALVE;
1462 
1463   //=== VK_EXT_depth_clamp_zero_one ===
1464   struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;
1465 
1466   //=== VK_EXT_non_seamless_cube_map ===
1467   struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
1468 
1469   //=== VK_QCOM_fragment_density_map_offset ===
1470   struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
1471   struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
1472   struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
1473 
1474   //=== VK_NV_copy_memory_indirect ===
1475   struct CopyMemoryIndirectCommandNV;
1476   struct CopyMemoryToImageIndirectCommandNV;
1477   struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
1478   struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;
1479 
1480   //=== VK_NV_memory_decompression ===
1481   struct DecompressMemoryRegionNV;
1482   struct PhysicalDeviceMemoryDecompressionFeaturesNV;
1483   struct PhysicalDeviceMemoryDecompressionPropertiesNV;
1484 
1485   //=== VK_NV_linear_color_attachment ===
1486   struct PhysicalDeviceLinearColorAttachmentFeaturesNV;
1487 
1488   //=== VK_EXT_image_compression_control_swapchain ===
1489   struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
1490 
1491   //=== VK_QCOM_image_processing ===
1492   struct ImageViewSampleWeightCreateInfoQCOM;
1493   struct PhysicalDeviceImageProcessingFeaturesQCOM;
1494   struct PhysicalDeviceImageProcessingPropertiesQCOM;
1495 
1496   //=== VK_EXT_extended_dynamic_state3 ===
1497   struct PhysicalDeviceExtendedDynamicState3FeaturesEXT;
1498   struct PhysicalDeviceExtendedDynamicState3PropertiesEXT;
1499   struct ColorBlendEquationEXT;
1500   struct ColorBlendAdvancedEXT;
1501 
1502   //=== VK_EXT_subpass_merge_feedback ===
1503   struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
1504   struct RenderPassCreationControlEXT;
1505   struct RenderPassCreationFeedbackInfoEXT;
1506   struct RenderPassCreationFeedbackCreateInfoEXT;
1507   struct RenderPassSubpassFeedbackInfoEXT;
1508   struct RenderPassSubpassFeedbackCreateInfoEXT;
1509 
1510   //=== VK_LUNARG_direct_driver_loading ===
1511   struct DirectDriverLoadingInfoLUNARG;
1512   struct DirectDriverLoadingListLUNARG;
1513 
1514   //=== VK_EXT_shader_module_identifier ===
1515   struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
1516   struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
1517   struct PipelineShaderStageModuleIdentifierCreateInfoEXT;
1518   struct ShaderModuleIdentifierEXT;
1519 
1520   //=== VK_EXT_rasterization_order_attachment_access ===
1521   struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1522   using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
1523 
1524   //=== VK_NV_optical_flow ===
1525   struct PhysicalDeviceOpticalFlowFeaturesNV;
1526   struct PhysicalDeviceOpticalFlowPropertiesNV;
1527   struct OpticalFlowImageFormatInfoNV;
1528   struct OpticalFlowImageFormatPropertiesNV;
1529   struct OpticalFlowSessionCreateInfoNV;
1530   struct OpticalFlowSessionCreatePrivateDataInfoNV;
1531   struct OpticalFlowExecuteInfoNV;
1532 
1533   //=== VK_EXT_legacy_dithering ===
1534   struct PhysicalDeviceLegacyDitheringFeaturesEXT;
1535 
1536   //=== VK_EXT_pipeline_protected_access ===
1537   struct PhysicalDevicePipelineProtectedAccessFeaturesEXT;
1538 
1539   //=== VK_QCOM_tile_properties ===
1540   struct PhysicalDeviceTilePropertiesFeaturesQCOM;
1541   struct TilePropertiesQCOM;
1542 
1543   //=== VK_SEC_amigo_profiling ===
1544   struct PhysicalDeviceAmigoProfilingFeaturesSEC;
1545   struct AmigoProfilingSubmitInfoSEC;
1546 
1547   //=== VK_QCOM_multiview_per_view_viewports ===
1548   struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
1549 
1550   //=== VK_NV_ray_tracing_invocation_reorder ===
1551   struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
1552   struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
1553 
1554   //=== VK_EXT_mutable_descriptor_type ===
1555   struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1556   using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
1557   struct MutableDescriptorTypeListEXT;
1558   using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
1559   struct MutableDescriptorTypeCreateInfoEXT;
1560   using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
1561 
1562   //=== VK_ARM_shader_core_builtins ===
1563   struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
1564   struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
1565 
1566 
1567 
1568   //===============
1569   //=== HANDLEs ===
1570   //===============
1571 
1572   template <typename Type>
1573   struct isVulkanHandleType
1574   {
1575     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
1576   };
1577 
1578   class SurfaceKHR
1579   {
1580   public:
1581     using CType = VkSurfaceKHR;
1582     using NativeType = VkSurfaceKHR;
1583 
1584     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
1585     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
1586 
1587   public:
1588     VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;
SurfaceKHR(std::nullptr_t)1589     VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1590     {}
SurfaceKHR(VkSurfaceKHR surfaceKHR)1591     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
1592       : m_surfaceKHR( surfaceKHR )
1593     {}
1594 
1595 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSurfaceKHR surfaceKHR)1596     SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
1597     {
1598       m_surfaceKHR = surfaceKHR;
1599       return *this;
1600     }
1601 #endif
1602 
operator =(std::nullptr_t)1603     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1604     {
1605       m_surfaceKHR = {};
1606       return *this;
1607     }
1608 
1609 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1610     auto operator<=>( SurfaceKHR const & ) const = default;
1611 #else
operator ==(SurfaceKHR const & rhs) const1612     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1613     {
1614       return m_surfaceKHR == rhs.m_surfaceKHR;
1615     }
1616 
operator !=(SurfaceKHR const & rhs) const1617     bool operator!=(SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1618     {
1619       return m_surfaceKHR != rhs.m_surfaceKHR;
1620     }
1621 
operator <(SurfaceKHR const & rhs) const1622     bool operator<(SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1623     {
1624       return m_surfaceKHR < rhs.m_surfaceKHR;
1625     }
1626 #endif
1627 
operator VkSurfaceKHR() const1628     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
1629     {
1630       return m_surfaceKHR;
1631     }
1632 
operator bool() const1633     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1634     {
1635       return m_surfaceKHR != VK_NULL_HANDLE;
1636     }
1637 
operator !() const1638     bool operator!() const VULKAN_HPP_NOEXCEPT
1639     {
1640       return m_surfaceKHR == VK_NULL_HANDLE;
1641     }
1642 
1643   private:
1644     VkSurfaceKHR m_surfaceKHR = {};
1645   };
1646 
1647   template <>
1648   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
1649   {
1650     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1651   };
1652 
1653 
1654   template <>
1655   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
1656   {
1657     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1658   };
1659 
1660 
1661   template <>
1662   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
1663   {
1664     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1665   };
1666 
1667   class DebugReportCallbackEXT
1668   {
1669   public:
1670     using CType = VkDebugReportCallbackEXT;
1671     using NativeType = VkDebugReportCallbackEXT;
1672 
1673     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
1674     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
1675 
1676   public:
1677     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
DebugReportCallbackEXT(std::nullptr_t)1678     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1679     {}
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)1680     VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1681       : m_debugReportCallbackEXT( debugReportCallbackEXT )
1682     {}
1683 
1684 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)1685     DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT
1686     {
1687       m_debugReportCallbackEXT = debugReportCallbackEXT;
1688       return *this;
1689     }
1690 #endif
1691 
operator =(std::nullptr_t)1692     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1693     {
1694       m_debugReportCallbackEXT = {};
1695       return *this;
1696     }
1697 
1698 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1699     auto operator<=>( DebugReportCallbackEXT const & ) const = default;
1700 #else
operator ==(DebugReportCallbackEXT const & rhs) const1701     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1702     {
1703       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
1704     }
1705 
operator !=(DebugReportCallbackEXT const & rhs) const1706     bool operator!=(DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1707     {
1708       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
1709     }
1710 
operator <(DebugReportCallbackEXT const & rhs) const1711     bool operator<(DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1712     {
1713       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
1714     }
1715 #endif
1716 
operator VkDebugReportCallbackEXT() const1717     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
1718     {
1719       return m_debugReportCallbackEXT;
1720     }
1721 
operator bool() const1722     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1723     {
1724       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
1725     }
1726 
operator !() const1727     bool operator!() const VULKAN_HPP_NOEXCEPT
1728     {
1729       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
1730     }
1731 
1732   private:
1733     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
1734   };
1735 
1736   template <>
1737   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
1738   {
1739     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1740   };
1741 
1742 
1743   template <>
1744   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
1745   {
1746     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1747   };
1748 
1749 
1750   template <>
1751   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
1752   {
1753     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1754   };
1755 
1756   class DebugUtilsMessengerEXT
1757   {
1758   public:
1759     using CType = VkDebugUtilsMessengerEXT;
1760     using NativeType = VkDebugUtilsMessengerEXT;
1761 
1762     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
1763     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
1764 
1765   public:
1766     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
DebugUtilsMessengerEXT(std::nullptr_t)1767     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1768     {}
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1769     VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1770       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
1771     {}
1772 
1773 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1774     DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
1775     {
1776       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
1777       return *this;
1778     }
1779 #endif
1780 
operator =(std::nullptr_t)1781     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1782     {
1783       m_debugUtilsMessengerEXT = {};
1784       return *this;
1785     }
1786 
1787 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1788     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
1789 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const1790     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1791     {
1792       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
1793     }
1794 
operator !=(DebugUtilsMessengerEXT const & rhs) const1795     bool operator!=(DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1796     {
1797       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
1798     }
1799 
operator <(DebugUtilsMessengerEXT const & rhs) const1800     bool operator<(DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1801     {
1802       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
1803     }
1804 #endif
1805 
operator VkDebugUtilsMessengerEXT() const1806     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
1807     {
1808       return m_debugUtilsMessengerEXT;
1809     }
1810 
operator bool() const1811     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1812     {
1813       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
1814     }
1815 
operator !() const1816     bool operator!() const VULKAN_HPP_NOEXCEPT
1817     {
1818       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
1819     }
1820 
1821   private:
1822     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
1823   };
1824 
1825   template <>
1826   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
1827   {
1828     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1829   };
1830 
1831 
1832 
1833   template <>
1834   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
1835   {
1836     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1837   };
1838 
1839   class DisplayKHR
1840   {
1841   public:
1842     using CType = VkDisplayKHR;
1843     using NativeType = VkDisplayKHR;
1844 
1845     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
1846     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
1847 
1848   public:
1849     VULKAN_HPP_CONSTEXPR DisplayKHR() = default;
DisplayKHR(std::nullptr_t)1850     VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1851     {}
DisplayKHR(VkDisplayKHR displayKHR)1852     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
1853       : m_displayKHR( displayKHR )
1854     {}
1855 
1856 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDisplayKHR displayKHR)1857     DisplayKHR & operator=(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
1858     {
1859       m_displayKHR = displayKHR;
1860       return *this;
1861     }
1862 #endif
1863 
operator =(std::nullptr_t)1864     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1865     {
1866       m_displayKHR = {};
1867       return *this;
1868     }
1869 
1870 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1871     auto operator<=>( DisplayKHR const & ) const = default;
1872 #else
operator ==(DisplayKHR const & rhs) const1873     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1874     {
1875       return m_displayKHR == rhs.m_displayKHR;
1876     }
1877 
operator !=(DisplayKHR const & rhs) const1878     bool operator!=(DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1879     {
1880       return m_displayKHR != rhs.m_displayKHR;
1881     }
1882 
operator <(DisplayKHR const & rhs) const1883     bool operator<(DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1884     {
1885       return m_displayKHR < rhs.m_displayKHR;
1886     }
1887 #endif
1888 
operator VkDisplayKHR() const1889     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
1890     {
1891       return m_displayKHR;
1892     }
1893 
operator bool() const1894     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1895     {
1896       return m_displayKHR != VK_NULL_HANDLE;
1897     }
1898 
operator !() const1899     bool operator!() const VULKAN_HPP_NOEXCEPT
1900     {
1901       return m_displayKHR == VK_NULL_HANDLE;
1902     }
1903 
1904   private:
1905     VkDisplayKHR m_displayKHR = {};
1906   };
1907 
1908   template <>
1909   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
1910   {
1911     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1912   };
1913 
1914 
1915   template <>
1916   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
1917   {
1918     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1919   };
1920 
1921 
1922   template <>
1923   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
1924   {
1925     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1926   };
1927 
1928   class SwapchainKHR
1929   {
1930   public:
1931     using CType = VkSwapchainKHR;
1932     using NativeType = VkSwapchainKHR;
1933 
1934     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
1935     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
1936 
1937   public:
1938     VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;
SwapchainKHR(std::nullptr_t)1939     VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1940     {}
SwapchainKHR(VkSwapchainKHR swapchainKHR)1941     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1942       : m_swapchainKHR( swapchainKHR )
1943     {}
1944 
1945 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSwapchainKHR swapchainKHR)1946     SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
1947     {
1948       m_swapchainKHR = swapchainKHR;
1949       return *this;
1950     }
1951 #endif
1952 
operator =(std::nullptr_t)1953     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1954     {
1955       m_swapchainKHR = {};
1956       return *this;
1957     }
1958 
1959 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
1960     auto operator<=>( SwapchainKHR const & ) const = default;
1961 #else
operator ==(SwapchainKHR const & rhs) const1962     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1963     {
1964       return m_swapchainKHR == rhs.m_swapchainKHR;
1965     }
1966 
operator !=(SwapchainKHR const & rhs) const1967     bool operator!=(SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1968     {
1969       return m_swapchainKHR != rhs.m_swapchainKHR;
1970     }
1971 
operator <(SwapchainKHR const & rhs) const1972     bool operator<(SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1973     {
1974       return m_swapchainKHR < rhs.m_swapchainKHR;
1975     }
1976 #endif
1977 
operator VkSwapchainKHR() const1978     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
1979     {
1980       return m_swapchainKHR;
1981     }
1982 
operator bool() const1983     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1984     {
1985       return m_swapchainKHR != VK_NULL_HANDLE;
1986     }
1987 
operator !() const1988     bool operator!() const VULKAN_HPP_NOEXCEPT
1989     {
1990       return m_swapchainKHR == VK_NULL_HANDLE;
1991     }
1992 
1993   private:
1994     VkSwapchainKHR m_swapchainKHR = {};
1995   };
1996 
1997   template <>
1998   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
1999   {
2000     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2001   };
2002 
2003 
2004   template <>
2005   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
2006   {
2007     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2008   };
2009 
2010 
2011   template <>
2012   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
2013   {
2014     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2015   };
2016 
2017   class Semaphore
2018   {
2019   public:
2020     using CType = VkSemaphore;
2021     using NativeType = VkSemaphore;
2022 
2023     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
2024     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
2025 
2026   public:
2027     VULKAN_HPP_CONSTEXPR Semaphore() = default;
Semaphore(std::nullptr_t)2028     VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2029     {}
Semaphore(VkSemaphore semaphore)2030     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2031       : m_semaphore( semaphore )
2032     {}
2033 
2034 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSemaphore semaphore)2035     Semaphore & operator=(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
2036     {
2037       m_semaphore = semaphore;
2038       return *this;
2039     }
2040 #endif
2041 
operator =(std::nullptr_t)2042     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2043     {
2044       m_semaphore = {};
2045       return *this;
2046     }
2047 
2048 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2049     auto operator<=>( Semaphore const & ) const = default;
2050 #else
operator ==(Semaphore const & rhs) const2051     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2052     {
2053       return m_semaphore == rhs.m_semaphore;
2054     }
2055 
operator !=(Semaphore const & rhs) const2056     bool operator!=(Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2057     {
2058       return m_semaphore != rhs.m_semaphore;
2059     }
2060 
operator <(Semaphore const & rhs) const2061     bool operator<(Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2062     {
2063       return m_semaphore < rhs.m_semaphore;
2064     }
2065 #endif
2066 
operator VkSemaphore() const2067     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
2068     {
2069       return m_semaphore;
2070     }
2071 
operator bool() const2072     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2073     {
2074       return m_semaphore != VK_NULL_HANDLE;
2075     }
2076 
operator !() const2077     bool operator!() const VULKAN_HPP_NOEXCEPT
2078     {
2079       return m_semaphore == VK_NULL_HANDLE;
2080     }
2081 
2082   private:
2083     VkSemaphore m_semaphore = {};
2084   };
2085 
2086   template <>
2087   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
2088   {
2089     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2090   };
2091 
2092 
2093   template <>
2094   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
2095   {
2096     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2097   };
2098 
2099 
2100   template <>
2101   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
2102   {
2103     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2104   };
2105 
2106   class Fence
2107   {
2108   public:
2109     using CType = VkFence;
2110     using NativeType = VkFence;
2111 
2112     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
2113     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
2114 
2115   public:
2116     VULKAN_HPP_CONSTEXPR Fence() = default;
Fence(std::nullptr_t)2117     VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2118     {}
Fence(VkFence fence)2119     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT
2120       : m_fence( fence )
2121     {}
2122 
2123 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkFence fence)2124     Fence & operator=(VkFence fence) VULKAN_HPP_NOEXCEPT
2125     {
2126       m_fence = fence;
2127       return *this;
2128     }
2129 #endif
2130 
operator =(std::nullptr_t)2131     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2132     {
2133       m_fence = {};
2134       return *this;
2135     }
2136 
2137 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2138     auto operator<=>( Fence const & ) const = default;
2139 #else
operator ==(Fence const & rhs) const2140     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2141     {
2142       return m_fence == rhs.m_fence;
2143     }
2144 
operator !=(Fence const & rhs) const2145     bool operator!=(Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2146     {
2147       return m_fence != rhs.m_fence;
2148     }
2149 
operator <(Fence const & rhs) const2150     bool operator<(Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2151     {
2152       return m_fence < rhs.m_fence;
2153     }
2154 #endif
2155 
operator VkFence() const2156     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
2157     {
2158       return m_fence;
2159     }
2160 
operator bool() const2161     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2162     {
2163       return m_fence != VK_NULL_HANDLE;
2164     }
2165 
operator !() const2166     bool operator!() const VULKAN_HPP_NOEXCEPT
2167     {
2168       return m_fence == VK_NULL_HANDLE;
2169     }
2170 
2171   private:
2172     VkFence m_fence = {};
2173   };
2174 
2175   template <>
2176   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
2177   {
2178     using Type = VULKAN_HPP_NAMESPACE::Fence;
2179   };
2180 
2181 
2182   template <>
2183   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
2184   {
2185     using Type = VULKAN_HPP_NAMESPACE::Fence;
2186   };
2187 
2188 
2189   template <>
2190   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
2191   {
2192     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2193   };
2194 
2195   class PerformanceConfigurationINTEL
2196   {
2197   public:
2198     using CType = VkPerformanceConfigurationINTEL;
2199     using NativeType = VkPerformanceConfigurationINTEL;
2200 
2201     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
2202     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2203 
2204   public:
2205     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
PerformanceConfigurationINTEL(std::nullptr_t)2206     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2207     {}
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2208     VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2209       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
2210     {}
2211 
2212 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)2213     PerformanceConfigurationINTEL & operator=(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT
2214     {
2215       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2216       return *this;
2217     }
2218 #endif
2219 
operator =(std::nullptr_t)2220     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2221     {
2222       m_performanceConfigurationINTEL = {};
2223       return *this;
2224     }
2225 
2226 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2227     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
2228 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const2229     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2230     {
2231       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
2232     }
2233 
operator !=(PerformanceConfigurationINTEL const & rhs) const2234     bool operator!=(PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2235     {
2236       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
2237     }
2238 
operator <(PerformanceConfigurationINTEL const & rhs) const2239     bool operator<(PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
2240     {
2241       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
2242     }
2243 #endif
2244 
operator VkPerformanceConfigurationINTEL() const2245     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
2246     {
2247       return m_performanceConfigurationINTEL;
2248     }
2249 
operator bool() const2250     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2251     {
2252       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
2253     }
2254 
operator !() const2255     bool operator!() const VULKAN_HPP_NOEXCEPT
2256     {
2257       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
2258     }
2259 
2260   private:
2261     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
2262   };
2263 
2264   template <>
2265   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
2266   {
2267     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
2268   };
2269 
2270 
2271 
2272   template <>
2273   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
2274   {
2275     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2276   };
2277 
2278   class QueryPool
2279   {
2280   public:
2281     using CType = VkQueryPool;
2282     using NativeType = VkQueryPool;
2283 
2284     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
2285     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
2286 
2287   public:
2288     VULKAN_HPP_CONSTEXPR QueryPool() = default;
QueryPool(std::nullptr_t)2289     VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2290     {}
QueryPool(VkQueryPool queryPool)2291     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
2292       : m_queryPool( queryPool )
2293     {}
2294 
2295 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkQueryPool queryPool)2296     QueryPool & operator=(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
2297     {
2298       m_queryPool = queryPool;
2299       return *this;
2300     }
2301 #endif
2302 
operator =(std::nullptr_t)2303     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2304     {
2305       m_queryPool = {};
2306       return *this;
2307     }
2308 
2309 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2310     auto operator<=>( QueryPool const & ) const = default;
2311 #else
operator ==(QueryPool const & rhs) const2312     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2313     {
2314       return m_queryPool == rhs.m_queryPool;
2315     }
2316 
operator !=(QueryPool const & rhs) const2317     bool operator!=(QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2318     {
2319       return m_queryPool != rhs.m_queryPool;
2320     }
2321 
operator <(QueryPool const & rhs) const2322     bool operator<(QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
2323     {
2324       return m_queryPool < rhs.m_queryPool;
2325     }
2326 #endif
2327 
operator VkQueryPool() const2328     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
2329     {
2330       return m_queryPool;
2331     }
2332 
operator bool() const2333     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2334     {
2335       return m_queryPool != VK_NULL_HANDLE;
2336     }
2337 
operator !() const2338     bool operator!() const VULKAN_HPP_NOEXCEPT
2339     {
2340       return m_queryPool == VK_NULL_HANDLE;
2341     }
2342 
2343   private:
2344     VkQueryPool m_queryPool = {};
2345   };
2346 
2347   template <>
2348   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
2349   {
2350     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2351   };
2352 
2353 
2354   template <>
2355   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
2356   {
2357     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
2358   };
2359 
2360 
2361   template <>
2362   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
2363   {
2364     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2365   };
2366 
2367   class Buffer
2368   {
2369   public:
2370     using CType = VkBuffer;
2371     using NativeType = VkBuffer;
2372 
2373     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
2374     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
2375 
2376   public:
2377     VULKAN_HPP_CONSTEXPR Buffer() = default;
Buffer(std::nullptr_t)2378     VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2379     {}
Buffer(VkBuffer buffer)2380     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
2381       : m_buffer( buffer )
2382     {}
2383 
2384 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBuffer buffer)2385     Buffer & operator=(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
2386     {
2387       m_buffer = buffer;
2388       return *this;
2389     }
2390 #endif
2391 
operator =(std::nullptr_t)2392     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2393     {
2394       m_buffer = {};
2395       return *this;
2396     }
2397 
2398 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2399     auto operator<=>( Buffer const & ) const = default;
2400 #else
operator ==(Buffer const & rhs) const2401     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2402     {
2403       return m_buffer == rhs.m_buffer;
2404     }
2405 
operator !=(Buffer const & rhs) const2406     bool operator!=(Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2407     {
2408       return m_buffer != rhs.m_buffer;
2409     }
2410 
operator <(Buffer const & rhs) const2411     bool operator<(Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2412     {
2413       return m_buffer < rhs.m_buffer;
2414     }
2415 #endif
2416 
operator VkBuffer() const2417     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
2418     {
2419       return m_buffer;
2420     }
2421 
operator bool() const2422     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2423     {
2424       return m_buffer != VK_NULL_HANDLE;
2425     }
2426 
operator !() const2427     bool operator!() const VULKAN_HPP_NOEXCEPT
2428     {
2429       return m_buffer == VK_NULL_HANDLE;
2430     }
2431 
2432   private:
2433     VkBuffer m_buffer = {};
2434   };
2435 
2436   template <>
2437   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
2438   {
2439     using Type = VULKAN_HPP_NAMESPACE::Buffer;
2440   };
2441 
2442 
2443   template <>
2444   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
2445   {
2446     using Type = VULKAN_HPP_NAMESPACE::Buffer;
2447   };
2448 
2449 
2450   template <>
2451   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
2452   {
2453     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2454   };
2455 
2456   class PipelineLayout
2457   {
2458   public:
2459     using CType = VkPipelineLayout;
2460     using NativeType = VkPipelineLayout;
2461 
2462     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
2463     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
2464 
2465   public:
2466     VULKAN_HPP_CONSTEXPR PipelineLayout() = default;
PipelineLayout(std::nullptr_t)2467     VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2468     {}
PipelineLayout(VkPipelineLayout pipelineLayout)2469     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
2470       : m_pipelineLayout( pipelineLayout )
2471     {}
2472 
2473 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipelineLayout pipelineLayout)2474     PipelineLayout & operator=(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
2475     {
2476       m_pipelineLayout = pipelineLayout;
2477       return *this;
2478     }
2479 #endif
2480 
operator =(std::nullptr_t)2481     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2482     {
2483       m_pipelineLayout = {};
2484       return *this;
2485     }
2486 
2487 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2488     auto operator<=>( PipelineLayout const & ) const = default;
2489 #else
operator ==(PipelineLayout const & rhs) const2490     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2491     {
2492       return m_pipelineLayout == rhs.m_pipelineLayout;
2493     }
2494 
operator !=(PipelineLayout const & rhs) const2495     bool operator!=(PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2496     {
2497       return m_pipelineLayout != rhs.m_pipelineLayout;
2498     }
2499 
operator <(PipelineLayout const & rhs) const2500     bool operator<(PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
2501     {
2502       return m_pipelineLayout < rhs.m_pipelineLayout;
2503     }
2504 #endif
2505 
operator VkPipelineLayout() const2506     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
2507     {
2508       return m_pipelineLayout;
2509     }
2510 
operator bool() const2511     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2512     {
2513       return m_pipelineLayout != VK_NULL_HANDLE;
2514     }
2515 
operator !() const2516     bool operator!() const VULKAN_HPP_NOEXCEPT
2517     {
2518       return m_pipelineLayout == VK_NULL_HANDLE;
2519     }
2520 
2521   private:
2522     VkPipelineLayout m_pipelineLayout = {};
2523   };
2524 
2525   template <>
2526   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
2527   {
2528     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2529   };
2530 
2531 
2532   template <>
2533   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
2534   {
2535     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2536   };
2537 
2538 
2539   template <>
2540   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
2541   {
2542     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2543   };
2544 
2545   class DescriptorSet
2546   {
2547   public:
2548     using CType = VkDescriptorSet;
2549     using NativeType = VkDescriptorSet;
2550 
2551     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
2552     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
2553 
2554   public:
2555     VULKAN_HPP_CONSTEXPR DescriptorSet() = default;
DescriptorSet(std::nullptr_t)2556     VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2557     {}
DescriptorSet(VkDescriptorSet descriptorSet)2558     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2559       : m_descriptorSet( descriptorSet )
2560     {}
2561 
2562 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorSet descriptorSet)2563     DescriptorSet & operator=(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
2564     {
2565       m_descriptorSet = descriptorSet;
2566       return *this;
2567     }
2568 #endif
2569 
operator =(std::nullptr_t)2570     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2571     {
2572       m_descriptorSet = {};
2573       return *this;
2574     }
2575 
2576 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2577     auto operator<=>( DescriptorSet const & ) const = default;
2578 #else
operator ==(DescriptorSet const & rhs) const2579     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2580     {
2581       return m_descriptorSet == rhs.m_descriptorSet;
2582     }
2583 
operator !=(DescriptorSet const & rhs) const2584     bool operator!=(DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2585     {
2586       return m_descriptorSet != rhs.m_descriptorSet;
2587     }
2588 
operator <(DescriptorSet const & rhs) const2589     bool operator<(DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2590     {
2591       return m_descriptorSet < rhs.m_descriptorSet;
2592     }
2593 #endif
2594 
operator VkDescriptorSet() const2595     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
2596     {
2597       return m_descriptorSet;
2598     }
2599 
operator bool() const2600     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2601     {
2602       return m_descriptorSet != VK_NULL_HANDLE;
2603     }
2604 
operator !() const2605     bool operator!() const VULKAN_HPP_NOEXCEPT
2606     {
2607       return m_descriptorSet == VK_NULL_HANDLE;
2608     }
2609 
2610   private:
2611     VkDescriptorSet m_descriptorSet = {};
2612   };
2613 
2614   template <>
2615   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
2616   {
2617     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2618   };
2619 
2620 
2621   template <>
2622   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
2623   {
2624     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2625   };
2626 
2627 
2628   template <>
2629   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
2630   {
2631     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2632   };
2633 
2634   class ImageView
2635   {
2636   public:
2637     using CType = VkImageView;
2638     using NativeType = VkImageView;
2639 
2640     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
2641     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
2642 
2643   public:
2644     VULKAN_HPP_CONSTEXPR ImageView() = default;
ImageView(std::nullptr_t)2645     VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2646     {}
ImageView(VkImageView imageView)2647     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
2648       : m_imageView( imageView )
2649     {}
2650 
2651 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkImageView imageView)2652     ImageView & operator=(VkImageView imageView) VULKAN_HPP_NOEXCEPT
2653     {
2654       m_imageView = imageView;
2655       return *this;
2656     }
2657 #endif
2658 
operator =(std::nullptr_t)2659     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2660     {
2661       m_imageView = {};
2662       return *this;
2663     }
2664 
2665 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2666     auto operator<=>( ImageView const & ) const = default;
2667 #else
operator ==(ImageView const & rhs) const2668     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2669     {
2670       return m_imageView == rhs.m_imageView;
2671     }
2672 
operator !=(ImageView const & rhs) const2673     bool operator!=(ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2674     {
2675       return m_imageView != rhs.m_imageView;
2676     }
2677 
operator <(ImageView const & rhs) const2678     bool operator<(ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2679     {
2680       return m_imageView < rhs.m_imageView;
2681     }
2682 #endif
2683 
operator VkImageView() const2684     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
2685     {
2686       return m_imageView;
2687     }
2688 
operator bool() const2689     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2690     {
2691       return m_imageView != VK_NULL_HANDLE;
2692     }
2693 
operator !() const2694     bool operator!() const VULKAN_HPP_NOEXCEPT
2695     {
2696       return m_imageView == VK_NULL_HANDLE;
2697     }
2698 
2699   private:
2700     VkImageView m_imageView = {};
2701   };
2702 
2703   template <>
2704   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
2705   {
2706     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2707   };
2708 
2709 
2710   template <>
2711   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
2712   {
2713     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2714   };
2715 
2716 
2717   template <>
2718   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
2719   {
2720     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2721   };
2722 
2723   class Pipeline
2724   {
2725   public:
2726     using CType = VkPipeline;
2727     using NativeType = VkPipeline;
2728 
2729     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
2730     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
2731 
2732   public:
2733     VULKAN_HPP_CONSTEXPR Pipeline() = default;
Pipeline(std::nullptr_t)2734     VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2735     {}
Pipeline(VkPipeline pipeline)2736     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
2737       : m_pipeline( pipeline )
2738     {}
2739 
2740 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipeline pipeline)2741     Pipeline & operator=(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
2742     {
2743       m_pipeline = pipeline;
2744       return *this;
2745     }
2746 #endif
2747 
operator =(std::nullptr_t)2748     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2749     {
2750       m_pipeline = {};
2751       return *this;
2752     }
2753 
2754 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2755     auto operator<=>( Pipeline const & ) const = default;
2756 #else
operator ==(Pipeline const & rhs) const2757     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2758     {
2759       return m_pipeline == rhs.m_pipeline;
2760     }
2761 
operator !=(Pipeline const & rhs) const2762     bool operator!=(Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2763     {
2764       return m_pipeline != rhs.m_pipeline;
2765     }
2766 
operator <(Pipeline const & rhs) const2767     bool operator<(Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2768     {
2769       return m_pipeline < rhs.m_pipeline;
2770     }
2771 #endif
2772 
operator VkPipeline() const2773     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
2774     {
2775       return m_pipeline;
2776     }
2777 
operator bool() const2778     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2779     {
2780       return m_pipeline != VK_NULL_HANDLE;
2781     }
2782 
operator !() const2783     bool operator!() const VULKAN_HPP_NOEXCEPT
2784     {
2785       return m_pipeline == VK_NULL_HANDLE;
2786     }
2787 
2788   private:
2789     VkPipeline m_pipeline = {};
2790   };
2791 
2792   template <>
2793   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
2794   {
2795     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2796   };
2797 
2798 
2799   template <>
2800   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
2801   {
2802     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2803   };
2804 
2805 
2806   template <>
2807   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
2808   {
2809     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2810   };
2811 
2812   class Image
2813   {
2814   public:
2815     using CType = VkImage;
2816     using NativeType = VkImage;
2817 
2818     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
2819     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
2820 
2821   public:
2822     VULKAN_HPP_CONSTEXPR Image() = default;
Image(std::nullptr_t)2823     VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2824     {}
Image(VkImage image)2825     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT
2826       : m_image( image )
2827     {}
2828 
2829 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkImage image)2830     Image & operator=(VkImage image) VULKAN_HPP_NOEXCEPT
2831     {
2832       m_image = image;
2833       return *this;
2834     }
2835 #endif
2836 
operator =(std::nullptr_t)2837     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2838     {
2839       m_image = {};
2840       return *this;
2841     }
2842 
2843 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2844     auto operator<=>( Image const & ) const = default;
2845 #else
operator ==(Image const & rhs) const2846     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2847     {
2848       return m_image == rhs.m_image;
2849     }
2850 
operator !=(Image const & rhs) const2851     bool operator!=(Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2852     {
2853       return m_image != rhs.m_image;
2854     }
2855 
operator <(Image const & rhs) const2856     bool operator<(Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2857     {
2858       return m_image < rhs.m_image;
2859     }
2860 #endif
2861 
operator VkImage() const2862     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
2863     {
2864       return m_image;
2865     }
2866 
operator bool() const2867     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2868     {
2869       return m_image != VK_NULL_HANDLE;
2870     }
2871 
operator !() const2872     bool operator!() const VULKAN_HPP_NOEXCEPT
2873     {
2874       return m_image == VK_NULL_HANDLE;
2875     }
2876 
2877   private:
2878     VkImage m_image = {};
2879   };
2880 
2881   template <>
2882   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
2883   {
2884     using Type = VULKAN_HPP_NAMESPACE::Image;
2885   };
2886 
2887 
2888   template <>
2889   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
2890   {
2891     using Type = VULKAN_HPP_NAMESPACE::Image;
2892   };
2893 
2894 
2895   template <>
2896   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
2897   {
2898     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2899   };
2900 
2901   class AccelerationStructureNV
2902   {
2903   public:
2904     using CType = VkAccelerationStructureNV;
2905     using NativeType = VkAccelerationStructureNV;
2906 
2907     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
2908     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
2909 
2910   public:
2911     VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
AccelerationStructureNV(std::nullptr_t)2912     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2913     {}
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)2914     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2915       : m_accelerationStructureNV( accelerationStructureNV )
2916     {}
2917 
2918 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkAccelerationStructureNV accelerationStructureNV)2919     AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT
2920     {
2921       m_accelerationStructureNV = accelerationStructureNV;
2922       return *this;
2923     }
2924 #endif
2925 
operator =(std::nullptr_t)2926     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2927     {
2928       m_accelerationStructureNV = {};
2929       return *this;
2930     }
2931 
2932 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
2933     auto operator<=>( AccelerationStructureNV const & ) const = default;
2934 #else
operator ==(AccelerationStructureNV const & rhs) const2935     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2936     {
2937       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
2938     }
2939 
operator !=(AccelerationStructureNV const & rhs) const2940     bool operator!=(AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2941     {
2942       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
2943     }
2944 
operator <(AccelerationStructureNV const & rhs) const2945     bool operator<(AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2946     {
2947       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
2948     }
2949 #endif
2950 
operator VkAccelerationStructureNV() const2951     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
2952     {
2953       return m_accelerationStructureNV;
2954     }
2955 
operator bool() const2956     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2957     {
2958       return m_accelerationStructureNV != VK_NULL_HANDLE;
2959     }
2960 
operator !() const2961     bool operator!() const VULKAN_HPP_NOEXCEPT
2962     {
2963       return m_accelerationStructureNV == VK_NULL_HANDLE;
2964     }
2965 
2966   private:
2967     VkAccelerationStructureNV m_accelerationStructureNV = {};
2968   };
2969 
2970   template <>
2971   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
2972   {
2973     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2974   };
2975 
2976 
2977   template <>
2978   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
2979   {
2980     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2981   };
2982 
2983 
2984   template <>
2985   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
2986   {
2987     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2988   };
2989 
2990   class OpticalFlowSessionNV
2991   {
2992   public:
2993     using CType = VkOpticalFlowSessionNV;
2994     using NativeType = VkOpticalFlowSessionNV;
2995 
2996     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
2997     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2998 
2999   public:
3000     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV() = default;
OpticalFlowSessionNV(std::nullptr_t)3001     VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3002     {}
OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV)3003     VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
3004       : m_opticalFlowSessionNV( opticalFlowSessionNV )
3005     {}
3006 
3007 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkOpticalFlowSessionNV opticalFlowSessionNV)3008     OpticalFlowSessionNV & operator=(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT
3009     {
3010       m_opticalFlowSessionNV = opticalFlowSessionNV;
3011       return *this;
3012     }
3013 #endif
3014 
operator =(std::nullptr_t)3015     OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3016     {
3017       m_opticalFlowSessionNV = {};
3018       return *this;
3019     }
3020 
3021 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3022     auto operator<=>( OpticalFlowSessionNV const & ) const = default;
3023 #else
operator ==(OpticalFlowSessionNV const & rhs) const3024     bool operator==( OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3025     {
3026       return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
3027     }
3028 
operator !=(OpticalFlowSessionNV const & rhs) const3029     bool operator!=(OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3030     {
3031       return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
3032     }
3033 
operator <(OpticalFlowSessionNV const & rhs) const3034     bool operator<(OpticalFlowSessionNV const & rhs ) const VULKAN_HPP_NOEXCEPT
3035     {
3036       return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
3037     }
3038 #endif
3039 
operator VkOpticalFlowSessionNV() const3040     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
3041     {
3042       return m_opticalFlowSessionNV;
3043     }
3044 
operator bool() const3045     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3046     {
3047       return m_opticalFlowSessionNV != VK_NULL_HANDLE;
3048     }
3049 
operator !() const3050     bool operator!() const VULKAN_HPP_NOEXCEPT
3051     {
3052       return m_opticalFlowSessionNV == VK_NULL_HANDLE;
3053     }
3054 
3055   private:
3056     VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
3057   };
3058 
3059   template <>
3060   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>
3061   {
3062     using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
3063   };
3064 
3065 
3066 
3067   template <>
3068   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
3069   {
3070     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3071   };
3072 
3073   class DescriptorUpdateTemplate
3074   {
3075   public:
3076     using CType = VkDescriptorUpdateTemplate;
3077     using NativeType = VkDescriptorUpdateTemplate;
3078 
3079     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
3080     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
3081 
3082   public:
3083     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
DescriptorUpdateTemplate(std::nullptr_t)3084     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3085     {}
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)3086     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3087       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
3088     {}
3089 
3090 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)3091     DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT
3092     {
3093       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
3094       return *this;
3095     }
3096 #endif
3097 
operator =(std::nullptr_t)3098     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3099     {
3100       m_descriptorUpdateTemplate = {};
3101       return *this;
3102     }
3103 
3104 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3105     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
3106 #else
operator ==(DescriptorUpdateTemplate const & rhs) const3107     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3108     {
3109       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
3110     }
3111 
operator !=(DescriptorUpdateTemplate const & rhs) const3112     bool operator!=(DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3113     {
3114       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
3115     }
3116 
operator <(DescriptorUpdateTemplate const & rhs) const3117     bool operator<(DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
3118     {
3119       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
3120     }
3121 #endif
3122 
operator VkDescriptorUpdateTemplate() const3123     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
3124     {
3125       return m_descriptorUpdateTemplate;
3126     }
3127 
operator bool() const3128     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3129     {
3130       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
3131     }
3132 
operator !() const3133     bool operator!() const VULKAN_HPP_NOEXCEPT
3134     {
3135       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
3136     }
3137 
3138   private:
3139     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
3140   };
3141 
3142   template <>
3143   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
3144   {
3145     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3146   };
3147 
3148 
3149   template <>
3150   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
3151   {
3152     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3153   };
3154 
3155 
3156   template <>
3157   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
3158   {
3159     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3160   };
3161   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
3162 
3163   class Event
3164   {
3165   public:
3166     using CType = VkEvent;
3167     using NativeType = VkEvent;
3168 
3169     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
3170     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
3171 
3172   public:
3173     VULKAN_HPP_CONSTEXPR Event() = default;
Event(std::nullptr_t)3174     VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3175     {}
Event(VkEvent event)3176     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT
3177       : m_event( event )
3178     {}
3179 
3180 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkEvent event)3181     Event & operator=(VkEvent event) VULKAN_HPP_NOEXCEPT
3182     {
3183       m_event = event;
3184       return *this;
3185     }
3186 #endif
3187 
operator =(std::nullptr_t)3188     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3189     {
3190       m_event = {};
3191       return *this;
3192     }
3193 
3194 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3195     auto operator<=>( Event const & ) const = default;
3196 #else
operator ==(Event const & rhs) const3197     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3198     {
3199       return m_event == rhs.m_event;
3200     }
3201 
operator !=(Event const & rhs) const3202     bool operator!=(Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3203     {
3204       return m_event != rhs.m_event;
3205     }
3206 
operator <(Event const & rhs) const3207     bool operator<(Event const & rhs ) const VULKAN_HPP_NOEXCEPT
3208     {
3209       return m_event < rhs.m_event;
3210     }
3211 #endif
3212 
operator VkEvent() const3213     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
3214     {
3215       return m_event;
3216     }
3217 
operator bool() const3218     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3219     {
3220       return m_event != VK_NULL_HANDLE;
3221     }
3222 
operator !() const3223     bool operator!() const VULKAN_HPP_NOEXCEPT
3224     {
3225       return m_event == VK_NULL_HANDLE;
3226     }
3227 
3228   private:
3229     VkEvent m_event = {};
3230   };
3231 
3232   template <>
3233   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
3234   {
3235     using Type = VULKAN_HPP_NAMESPACE::Event;
3236   };
3237 
3238 
3239   template <>
3240   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
3241   {
3242     using Type = VULKAN_HPP_NAMESPACE::Event;
3243   };
3244 
3245 
3246   template <>
3247   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
3248   {
3249     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3250   };
3251 
3252   class AccelerationStructureKHR
3253   {
3254   public:
3255     using CType = VkAccelerationStructureKHR;
3256     using NativeType = VkAccelerationStructureKHR;
3257 
3258     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
3259     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
3260 
3261   public:
3262     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
AccelerationStructureKHR(std::nullptr_t)3263     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3264     {}
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)3265     VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
3266       : m_accelerationStructureKHR( accelerationStructureKHR )
3267     {}
3268 
3269 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkAccelerationStructureKHR accelerationStructureKHR)3270     AccelerationStructureKHR & operator=(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT
3271     {
3272       m_accelerationStructureKHR = accelerationStructureKHR;
3273       return *this;
3274     }
3275 #endif
3276 
operator =(std::nullptr_t)3277     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3278     {
3279       m_accelerationStructureKHR = {};
3280       return *this;
3281     }
3282 
3283 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3284     auto operator<=>( AccelerationStructureKHR const & ) const = default;
3285 #else
operator ==(AccelerationStructureKHR const & rhs) const3286     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3287     {
3288       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
3289     }
3290 
operator !=(AccelerationStructureKHR const & rhs) const3291     bool operator!=(AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3292     {
3293       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
3294     }
3295 
operator <(AccelerationStructureKHR const & rhs) const3296     bool operator<(AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
3297     {
3298       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
3299     }
3300 #endif
3301 
operator VkAccelerationStructureKHR() const3302     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
3303     {
3304       return m_accelerationStructureKHR;
3305     }
3306 
operator bool() const3307     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3308     {
3309       return m_accelerationStructureKHR != VK_NULL_HANDLE;
3310     }
3311 
operator !() const3312     bool operator!() const VULKAN_HPP_NOEXCEPT
3313     {
3314       return m_accelerationStructureKHR == VK_NULL_HANDLE;
3315     }
3316 
3317   private:
3318     VkAccelerationStructureKHR m_accelerationStructureKHR = {};
3319   };
3320 
3321   template <>
3322   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
3323   {
3324     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3325   };
3326 
3327 
3328   template <>
3329   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
3330   {
3331     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
3332   };
3333 
3334 
3335   template <>
3336   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
3337   {
3338     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3339   };
3340 
3341   class MicromapEXT
3342   {
3343   public:
3344     using CType = VkMicromapEXT;
3345     using NativeType = VkMicromapEXT;
3346 
3347     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
3348     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3349 
3350   public:
3351     VULKAN_HPP_CONSTEXPR MicromapEXT() = default;
MicromapEXT(std::nullptr_t)3352     VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3353     {}
MicromapEXT(VkMicromapEXT micromapEXT)3354     VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
3355       : m_micromapEXT( micromapEXT )
3356     {}
3357 
3358 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkMicromapEXT micromapEXT)3359     MicromapEXT & operator=(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT
3360     {
3361       m_micromapEXT = micromapEXT;
3362       return *this;
3363     }
3364 #endif
3365 
operator =(std::nullptr_t)3366     MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3367     {
3368       m_micromapEXT = {};
3369       return *this;
3370     }
3371 
3372 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3373     auto operator<=>( MicromapEXT const & ) const = default;
3374 #else
operator ==(MicromapEXT const & rhs) const3375     bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3376     {
3377       return m_micromapEXT == rhs.m_micromapEXT;
3378     }
3379 
operator !=(MicromapEXT const & rhs) const3380     bool operator!=(MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3381     {
3382       return m_micromapEXT != rhs.m_micromapEXT;
3383     }
3384 
operator <(MicromapEXT const & rhs) const3385     bool operator<(MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3386     {
3387       return m_micromapEXT < rhs.m_micromapEXT;
3388     }
3389 #endif
3390 
operator VkMicromapEXT() const3391     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT
3392     {
3393       return m_micromapEXT;
3394     }
3395 
operator bool() const3396     explicit operator bool() const VULKAN_HPP_NOEXCEPT
3397     {
3398       return m_micromapEXT != VK_NULL_HANDLE;
3399     }
3400 
operator !() const3401     bool operator!() const VULKAN_HPP_NOEXCEPT
3402     {
3403       return m_micromapEXT == VK_NULL_HANDLE;
3404     }
3405 
3406   private:
3407     VkMicromapEXT m_micromapEXT = {};
3408   };
3409 
3410   template <>
3411   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>
3412   {
3413     using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
3414   };
3415 
3416 
3417 
3418   template <>
3419   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>
3420   {
3421     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3422   };
3423 
3424   class CommandBuffer
3425   {
3426   public:
3427     using CType = VkCommandBuffer;
3428     using NativeType = VkCommandBuffer;
3429 
3430     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
3431     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
3432 
3433   public:
3434     VULKAN_HPP_CONSTEXPR CommandBuffer() = default;
CommandBuffer(std::nullptr_t)3435     VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3436     {}
CommandBuffer(VkCommandBuffer commandBuffer)3437     CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
3438       : m_commandBuffer( commandBuffer )
3439     {}
3440 
operator =(VkCommandBuffer commandBuffer)3441     CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
3442     {
3443       m_commandBuffer = commandBuffer;
3444       return *this;
3445     }
3446 
operator =(std::nullptr_t)3447     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
3448     {
3449       m_commandBuffer = {};
3450       return *this;
3451     }
3452 
3453 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
3454     auto operator<=>( CommandBuffer const & ) const = default;
3455 #else
operator ==(CommandBuffer const & rhs) const3456     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3457     {
3458       return m_commandBuffer == rhs.m_commandBuffer;
3459     }
3460 
operator !=(CommandBuffer const & rhs) const3461     bool operator!=(CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3462     {
3463       return m_commandBuffer != rhs.m_commandBuffer;
3464     }
3465 
operator <(CommandBuffer const & rhs) const3466     bool operator<(CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3467     {
3468       return m_commandBuffer < rhs.m_commandBuffer;
3469     }
3470 #endif
3471 
3472   //=== VK_VERSION_1_0 ===
3473 
3474 
3475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3476     VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3479     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3480 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3481 
3482 
3483 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3484     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3485     VULKAN_HPP_NODISCARD Result end( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3486 #else
3487     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3488     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3489 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3490 
3491 
3492 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
3493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3494     VULKAN_HPP_NODISCARD Result reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3495 #else
3496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3497     typename ResultValueType<void>::type reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
3498 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3499 
3500 
3501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3502     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3503 
3504 
3505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3506     void setViewport( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3509     void setViewport( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3511 
3512 
3513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3514     void setScissor( uint32_t firstScissor, uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3515 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3517     void setScissor( uint32_t firstScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3519 
3520 
3521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3522     void setLineWidth( float lineWidth, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3523 
3524 
3525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3526     void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3527 
3528 
3529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3530     void setBlendConstants( const float blendConstants[4], Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3531 
3532 
3533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3534     void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3535 
3536 
3537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3538     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3539 
3540 
3541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3542     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3543 
3544 
3545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3546     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3547 
3548 
3549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3550     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t * pDynamicOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3551 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3552     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3553     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3555 
3556 
3557     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3558     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::IndexType indexType, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3559 
3560 
3561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3562     void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3565     void bindVertexBuffers( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3566 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3567 
3568 
3569     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3570     void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3571 
3572 
3573     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3574     void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3575 
3576 
3577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3578     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3579 
3580 
3581     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3582     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3583 
3584 
3585     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3586     void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3587 
3588 
3589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3590     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3591 
3592 
3593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3594     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3595 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3597     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3598 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3599 
3600 
3601     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3602     void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3603 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3604     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3605     void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3607 
3608 
3609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3610     void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3611 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3612     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3613     void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, VULKAN_HPP_NAMESPACE::Filter filter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3614 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3615 
3616 
3617     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3618     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3619 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3620     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3621     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3622 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3623 
3624 
3625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3626     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3629     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3630 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3631 
3632 
3633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3634     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dataSize, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3635 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3636     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3637     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3638 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3639 
3640 
3641     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3642     void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize size, uint32_t data, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3643 
3644 
3645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3646     void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3647 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3649     void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearColorValue & color, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3650 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3651 
3652 
3653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3654     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil, uint32_t rangeCount, const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3656     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3657     void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3658 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3659 
3660 
3661     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3662     void clearAttachments( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments, uint32_t rectCount, const VULKAN_HPP_NAMESPACE::ClearRect * pRects, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3663 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3664     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3665     void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3666 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3667 
3668 
3669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3670     void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, uint32_t regionCount, const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3673     void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3674 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3675 
3676 
3677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3678     void setEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3679 
3680 
3681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3682     void resetEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3683 
3684 
3685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3686     void waitEvents( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3687 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3689     void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3690 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3691 
3692 
3693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3694     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3696     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3697     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3698 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3699 
3700 
3701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3702     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3703 
3704 
3705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3706     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3707 
3708 
3709     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3710     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3711 
3712 
3713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3714     void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3715 
3716 
3717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3718     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3719 
3720 
3721     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3722     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3724     template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3725     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, uint32_t offset, VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3726 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3727 
3728 
3729     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3730     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3731 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3732     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3733     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3734 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3735 
3736 
3737     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3738     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3739 
3740 
3741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3742     void endRenderPass( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3743 
3744 
3745     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3746     void executeCommands( uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3747 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3748     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3749     void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3750 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3751 
3752   //=== VK_VERSION_1_1 ===
3753 
3754 
3755     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3756     void setDeviceMask( uint32_t deviceMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3757 
3758 
3759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3760     void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3761 
3762   //=== VK_VERSION_1_2 ===
3763 
3764 
3765     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3766     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3767 
3768 
3769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3770     void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3771 
3772 
3773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3774     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3776     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3777     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3778 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3779 
3780 
3781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3782     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3783 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3785     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3786 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3787 
3788 
3789     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3790     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, 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, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3794 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3795 
3796   //=== VK_VERSION_1_3 ===
3797 
3798 
3799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3800     void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3803     void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3804 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3805 
3806 
3807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3808     void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3809 
3810 
3811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3812     void waitEvents2( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3815     void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3816 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3817 
3818 
3819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3820     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3821 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3823     void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3824 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3825 
3826 
3827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3828     void writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3829 
3830 
3831     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3832     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3833 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3834     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3835     void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3836 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3837 
3838 
3839     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3840     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3841 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3842     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3843     void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3844 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3845 
3846 
3847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3848     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3851     void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3853 
3854 
3855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3856     void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, 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 copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3860 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3861 
3862 
3863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3864     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3867     void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3869 
3870 
3871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3872     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3875     void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3876 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3877 
3878 
3879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3880     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3881 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3883     void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3884 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3885 
3886 
3887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3888     void endRendering( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3889 
3890 
3891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3892     void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3893 
3894 
3895     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3896     void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3897 
3898 
3899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3900     void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3901 
3902 
3903     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3904     void setViewportWithCount( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3905 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3907     void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3908 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3909 
3910 
3911     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3912     void setScissorWithCount( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3915     void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3916 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3917 
3918 
3919     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3920     void bindVertexBuffers2( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3921 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3923     void bindVertexBuffers2( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3925 
3926 
3927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3928     void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3929 
3930 
3931     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3932     void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3933 
3934 
3935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3936     void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3937 
3938 
3939     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3940     void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3941 
3942 
3943     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3944     void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3945 
3946 
3947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3948     void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3949 
3950 
3951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3952     void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3953 
3954 
3955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3956     void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3957 
3958 
3959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3960     void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3961 
3962   //=== VK_EXT_debug_marker ===
3963 
3964 
3965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3966     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3967 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3969     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3970 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3971 
3972 
3973     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3974     void debugMarkerEndEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3975 
3976 
3977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3978     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3981     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3983 
3984   //=== VK_KHR_video_queue ===
3985 
3986 
3987     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3988     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3991     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3992 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
3993 
3994 
3995     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3996     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3998     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3999     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4000 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4001 
4002 
4003     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4004     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4005 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4006     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4007     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4008 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4009 
4010   //=== VK_KHR_video_decode_queue ===
4011 
4012 
4013     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4014     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4015 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4017     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4018 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4019 
4020   //=== VK_EXT_transform_feedback ===
4021 
4022 
4023     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4024     void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4026     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4027     void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4029 
4030 
4031     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4032     void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4033 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4034     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4035     void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4036 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4037 
4038 
4039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4040     void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4041 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4042     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4043     void endTransformFeedbackEXT( uint32_t firstCounterBuffer, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4044 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4045 
4046 
4047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4048     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, VULKAN_HPP_NAMESPACE::QueryControlFlags flags, uint32_t index, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4049 
4050 
4051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4052     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4053 
4054 
4055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4056     void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, VULKAN_HPP_NAMESPACE::Buffer counterBuffer, VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4057 
4058   //=== VK_NVX_binary_import ===
4059 
4060 
4061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4062     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4065     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4067 
4068   //=== VK_AMD_draw_indirect_count ===
4069 
4070 
4071     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4072     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4073 
4074 
4075     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4076     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4077 
4078   //=== VK_KHR_dynamic_rendering ===
4079 
4080 
4081     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4082     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4085     void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4086 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4087 
4088 
4089     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4090     void endRenderingKHR( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4091 
4092   //=== VK_KHR_device_group ===
4093 
4094 
4095     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4096     void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4097 
4098 
4099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4100     void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4101 
4102   //=== VK_KHR_push_descriptor ===
4103 
4104 
4105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4106     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4108     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4109     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4110 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4111 
4112 
4113     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4114     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4115 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4116     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4117     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4118 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4119 
4120   //=== VK_EXT_conditional_rendering ===
4121 
4122 
4123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4124     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4126     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4127     void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4128 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4129 
4130 
4131     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4132     void endConditionalRenderingEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4133 
4134   //=== VK_NV_clip_space_w_scaling ===
4135 
4136 
4137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4138     void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4141     void setViewportWScalingNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4142 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4143 
4144   //=== VK_EXT_discard_rectangles ===
4145 
4146 
4147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4148     void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4149 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4150     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4151     void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4152 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4153 
4154   //=== VK_KHR_create_renderpass2 ===
4155 
4156 
4157     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4158     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4159 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4161     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4162 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4163 
4164 
4165     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4166     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4167 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4168     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4169     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4170 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4171 
4172 
4173     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4174     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4176     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4177     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4178 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4179 
4180   //=== VK_EXT_debug_utils ===
4181 
4182 
4183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4184     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4185 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4187     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4188 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4189 
4190 
4191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4192     void endDebugUtilsLabelEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4193 
4194 
4195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4196     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4199     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4200 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4201 
4202   //=== VK_EXT_sample_locations ===
4203 
4204 
4205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4206     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4207 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4208     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4209     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4211 
4212   //=== VK_KHR_acceleration_structure ===
4213 
4214 
4215     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4216     void buildAccelerationStructuresKHR( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4218     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4219     void buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4220 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4221 
4222 
4223     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4224     void buildAccelerationStructuresIndirectKHR( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses, const uint32_t * pIndirectStrides, const uint32_t * const * ppMaxPrimitiveCounts, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4227     void buildAccelerationStructuresIndirectKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4228 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4229 
4230 
4231     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4232     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4233 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4235     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4236 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4237 
4238 
4239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4240     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4241 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4243     void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4245 
4246 
4247     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4248     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4249 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4251     void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4252 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4253 
4254 
4255     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4256     void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4259     void writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4260 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4261 
4262   //=== VK_NV_shading_rate_image ===
4263 
4264 
4265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4266     void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4267 
4268 
4269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4270     void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4272     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4273     void setViewportShadingRatePaletteNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4274 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4275 
4276 
4277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4278     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4280     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4281     void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4282 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4283 
4284   //=== VK_NV_ray_tracing ===
4285 
4286 
4287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4288     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4289 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4291     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, VULKAN_HPP_NAMESPACE::Buffer instanceData, VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, VULKAN_HPP_NAMESPACE::Bool32 update, VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::Buffer scratch, VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4292 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4293 
4294 
4295     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4296     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4297 
4298 
4299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4300     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4301 
4302 
4303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4304     void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4307     void writeAccelerationStructuresPropertiesNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4308 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4309 
4310   //=== VK_KHR_draw_indirect_count ===
4311 
4312 
4313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4314     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4315 
4316 
4317     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4318     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4319 
4320   //=== VK_AMD_buffer_marker ===
4321 
4322 
4323     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4324     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4325 
4326   //=== VK_NV_mesh_shader ===
4327 
4328 
4329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4330     void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4331 
4332 
4333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4334     void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4335 
4336 
4337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4338     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4339 
4340   //=== VK_NV_scissor_exclusive ===
4341 
4342 
4343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4344     void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4346     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4347     void setExclusiveScissorNV( uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4348 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4349 
4350   //=== VK_NV_device_diagnostic_checkpoints ===
4351 
4352 
4353     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4354     void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4355 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4356     template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4357     void setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4359 
4360   //=== VK_INTEL_performance_query ===
4361 
4362 
4363     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4364     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4365 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4367     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4368 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4369 
4370 
4371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4372     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4373 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4375     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4376 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4377 
4378 
4379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4380     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4381 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4383     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4384 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4385 
4386   //=== VK_KHR_fragment_shading_rate ===
4387 
4388 
4389     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4390     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4393     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4394 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4395 
4396   //=== VK_EXT_line_rasterization ===
4397 
4398 
4399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4400     void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4401 
4402   //=== VK_EXT_extended_dynamic_state ===
4403 
4404 
4405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4406     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4407 
4408 
4409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4410     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4411 
4412 
4413     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4414     void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4415 
4416 
4417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4418     void setViewportWithCountEXT( uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::Viewport * pViewports, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4419 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4420     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4421     void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4422 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4423 
4424 
4425     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4426     void setScissorWithCountEXT( uint32_t scissorCount, const VULKAN_HPP_NAMESPACE::Rect2D * pScissors, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4428     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4429     void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4430 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4431 
4432 
4433     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4434     void bindVertexBuffers2EXT( uint32_t firstBinding, uint32_t bindingCount, const VULKAN_HPP_NAMESPACE::Buffer * pBuffers, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes, const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4435 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4437     void bindVertexBuffers2EXT( uint32_t firstBinding, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4438 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4439 
4440 
4441     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4442     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4443 
4444 
4445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4446     void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4447 
4448 
4449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4450     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4451 
4452 
4453     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4454     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4455 
4456 
4457     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4458     void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4459 
4460 
4461     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4462     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, VULKAN_HPP_NAMESPACE::StencilOp failOp, VULKAN_HPP_NAMESPACE::StencilOp passOp, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4463 
4464   //=== VK_NV_device_generated_commands ===
4465 
4466 
4467     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4468     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4471     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4473 
4474 
4475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4476     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4479     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4480 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4481 
4482 
4483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4484     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t groupIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4485 
4486 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4487   //=== VK_KHR_video_encode_queue ===
4488 
4489 
4490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4491     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4492 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4494     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4495 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4496 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
4497 
4498   //=== VK_KHR_synchronization2 ===
4499 
4500 
4501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4502     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4503 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4504     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4505     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4507 
4508 
4509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4510     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4511 
4512 
4513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4514     void waitEvents2KHR( uint32_t eventCount, const VULKAN_HPP_NAMESPACE::Event * pEvents, const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos, 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 waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4519 
4520 
4521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4522     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4523 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4525     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4526 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4527 
4528 
4529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4530     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4531 
4532 
4533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4534     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, uint32_t marker, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4535 
4536   //=== VK_EXT_descriptor_buffer ===
4537 
4538 
4539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4540     void bindDescriptorBuffersEXT( uint32_t bufferCount, const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4542     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4543     void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4544 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4545 
4546 
4547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4548     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t * pBufferIndices, const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4551     void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t firstSet, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4553 
4554 
4555     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4556     void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4557 
4558   //=== VK_NV_fragment_shading_rate_enums ===
4559 
4560 
4561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4562     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4563 
4564   //=== VK_EXT_mesh_shader ===
4565 
4566 
4567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4568     void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4569 
4570 
4571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4572     void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4573 
4574 
4575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4576     void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::Buffer countBuffer, VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4577 
4578   //=== VK_KHR_copy_commands2 ===
4579 
4580 
4581     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4582     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4585     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4586 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4587 
4588 
4589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4590     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4591 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4593     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4594 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4595 
4596 
4597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4598     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4599 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4600     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4601     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4602 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4603 
4604 
4605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4606     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4607 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4608     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4609     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4610 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4611 
4612 
4613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4614     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4615 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4617     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4618 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4619 
4620 
4621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4622     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4625     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4626 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4627 
4628   //=== VK_KHR_ray_tracing_pipeline ===
4629 
4630 
4631     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4632     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4635     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4637 
4638 
4639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4640     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4643     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4645 
4646 
4647     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4648     void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4649 
4650   //=== VK_EXT_vertex_input_dynamic_state ===
4651 
4652 
4653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4654     void setVertexInputEXT( uint32_t vertexBindingDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4656     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4657     void setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4658 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4659 
4660   //=== VK_HUAWEI_subpass_shading ===
4661 
4662 
4663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4664     void subpassShadingHUAWEI( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4665 
4666   //=== VK_HUAWEI_invocation_mask ===
4667 
4668 
4669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4670     void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4671 
4672   //=== VK_EXT_extended_dynamic_state2 ===
4673 
4674 
4675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4676     void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4677 
4678 
4679     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4680     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4681 
4682 
4683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4684     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4685 
4686 
4687     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4688     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4689 
4690 
4691     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4692     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4693 
4694   //=== VK_EXT_color_write_enable ===
4695 
4696 
4697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4698     void setColorWriteEnableEXT( uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4699 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4701     void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4702 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4703 
4704   //=== VK_KHR_ray_tracing_maintenance1 ===
4705 
4706 
4707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4708     void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4709 
4710   //=== VK_EXT_multi_draw ===
4711 
4712 
4713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4714     void drawMultiEXT( uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4715 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4716     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4717     void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, uint32_t instanceCount, uint32_t firstInstance, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4719 
4720 
4721     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4722     void drawMultiIndexedEXT( uint32_t drawCount, const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t * pVertexOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4725     void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, uint32_t instanceCount, uint32_t firstInstance, Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4726 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4727 
4728   //=== VK_EXT_opacity_micromap ===
4729 
4730 
4731     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4732     void buildMicromapsEXT( uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4733 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4734     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4735     void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4736 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4737 
4738 
4739     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4740     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4741 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4743     void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4744 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4745 
4746 
4747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4748     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4750     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4751     void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4753 
4754 
4755     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4756     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4757 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4759     void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4760 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4761 
4762 
4763     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4764     void writeMicromapsPropertiesEXT( uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4767     void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4768 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4769 
4770   //=== VK_HUAWEI_cluster_culling_shader ===
4771 
4772 
4773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4774     void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4775 
4776 
4777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4778     void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4779 
4780   //=== VK_NV_copy_memory_indirect ===
4781 
4782 
4783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4784     void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4785 
4786 
4787     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4788     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4789 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4791     void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t stride, VULKAN_HPP_NAMESPACE::Image dstImage, VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4792 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4793 
4794   //=== VK_NV_memory_decompression ===
4795 
4796 
4797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4798     void decompressMemoryNV( uint32_t decompressRegionCount, const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4801     void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4802 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4803 
4804 
4805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4806     void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4807 
4808   //=== VK_EXT_extended_dynamic_state3 ===
4809 
4810 
4811     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4812     void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4813 
4814 
4815     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4816     void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4817 
4818 
4819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4820     void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4821 
4822 
4823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4824     void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4825 
4826 
4827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4828     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, const VULKAN_HPP_NAMESPACE::SampleMask * pSampleMask, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4829 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4831     void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4833 
4834 
4835     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4836     void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4837 
4838 
4839     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4840     void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4841 
4842 
4843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4844     void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4845 
4846 
4847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4848     void setColorBlendEnableEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4851     void setColorBlendEnableEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4853 
4854 
4855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4856     void setColorBlendEquationEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4857 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4859     void setColorBlendEquationEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4860 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4861 
4862 
4863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4864     void setColorWriteMaskEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4867     void setColorWriteMaskEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4869 
4870 
4871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4872     void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4873 
4874 
4875     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4876     void setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4877 
4878 
4879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4880     void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4881 
4882 
4883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4884     void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4885 
4886 
4887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4888     void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4889 
4890 
4891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4892     void setColorBlendAdvancedEXT( uint32_t firstAttachment, uint32_t attachmentCount, const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4893 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4895     void setColorBlendAdvancedEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4896 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4897 
4898 
4899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4900     void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4901 
4902 
4903     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4904     void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4905 
4906 
4907     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4908     void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4909 
4910 
4911     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4912     void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4913 
4914 
4915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4916     void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4917 
4918 
4919     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4920     void setViewportSwizzleNV( uint32_t firstViewport, uint32_t viewportCount, const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4921 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4923     void setViewportSwizzleNV( uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4925 
4926 
4927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4928     void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4929 
4930 
4931     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4932     void setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4933 
4934 
4935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4936     void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4937 
4938 
4939     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4940     void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4941 
4942 
4943     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4944     void setCoverageModulationTableNV( uint32_t coverageModulationTableCount, const float * pCoverageModulationTable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4946     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4947     void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4948 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4949 
4950 
4951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4952     void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4953 
4954 
4955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4956     void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4957 
4958 
4959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4960     void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4961 
4962   //=== VK_NV_optical_flow ===
4963 
4964 
4965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4966     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4967 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4969     void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4970 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4971 
operator VkCommandBuffer() const4972     operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
4973     {
4974       return m_commandBuffer;
4975     }
4976 
operator bool() const4977     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4978     {
4979       return m_commandBuffer != VK_NULL_HANDLE;
4980     }
4981 
operator !() const4982     bool operator!() const VULKAN_HPP_NOEXCEPT
4983     {
4984       return m_commandBuffer == VK_NULL_HANDLE;
4985     }
4986 
4987   private:
4988     VkCommandBuffer m_commandBuffer = {};
4989   };
4990 
4991   template <>
4992   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
4993   {
4994     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4995   };
4996 
4997 
4998   template <>
4999   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
5000   {
5001     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
5002   };
5003 
5004 
5005   template <>
5006   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
5007   {
5008     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5009   };
5010 
5011   class DeviceMemory
5012   {
5013   public:
5014     using CType = VkDeviceMemory;
5015     using NativeType = VkDeviceMemory;
5016 
5017     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
5018     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
5019 
5020   public:
5021     VULKAN_HPP_CONSTEXPR DeviceMemory() = default;
DeviceMemory(std::nullptr_t)5022     VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5023     {}
DeviceMemory(VkDeviceMemory deviceMemory)5024     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
5025       : m_deviceMemory( deviceMemory )
5026     {}
5027 
5028 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDeviceMemory deviceMemory)5029     DeviceMemory & operator=(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
5030     {
5031       m_deviceMemory = deviceMemory;
5032       return *this;
5033     }
5034 #endif
5035 
operator =(std::nullptr_t)5036     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5037     {
5038       m_deviceMemory = {};
5039       return *this;
5040     }
5041 
5042 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5043     auto operator<=>( DeviceMemory const & ) const = default;
5044 #else
operator ==(DeviceMemory const & rhs) const5045     bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5046     {
5047       return m_deviceMemory == rhs.m_deviceMemory;
5048     }
5049 
operator !=(DeviceMemory const & rhs) const5050     bool operator!=(DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5051     {
5052       return m_deviceMemory != rhs.m_deviceMemory;
5053     }
5054 
operator <(DeviceMemory const & rhs) const5055     bool operator<(DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
5056     {
5057       return m_deviceMemory < rhs.m_deviceMemory;
5058     }
5059 #endif
5060 
operator VkDeviceMemory() const5061     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
5062     {
5063       return m_deviceMemory;
5064     }
5065 
operator bool() const5066     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5067     {
5068       return m_deviceMemory != VK_NULL_HANDLE;
5069     }
5070 
operator !() const5071     bool operator!() const VULKAN_HPP_NOEXCEPT
5072     {
5073       return m_deviceMemory == VK_NULL_HANDLE;
5074     }
5075 
5076   private:
5077     VkDeviceMemory m_deviceMemory = {};
5078   };
5079 
5080   template <>
5081   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
5082   {
5083     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
5084   };
5085 
5086 
5087   template <>
5088   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
5089   {
5090     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
5091   };
5092 
5093 
5094   template <>
5095   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
5096   {
5097     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5098   };
5099 
5100   class VideoSessionKHR
5101   {
5102   public:
5103     using CType = VkVideoSessionKHR;
5104     using NativeType = VkVideoSessionKHR;
5105 
5106     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
5107     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5108 
5109   public:
5110     VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default;
VideoSessionKHR(std::nullptr_t)5111     VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5112     {}
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)5113     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
5114       : m_videoSessionKHR( videoSessionKHR )
5115     {}
5116 
5117 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkVideoSessionKHR videoSessionKHR)5118     VideoSessionKHR & operator=(VkVideoSessionKHR videoSessionKHR) VULKAN_HPP_NOEXCEPT
5119     {
5120       m_videoSessionKHR = videoSessionKHR;
5121       return *this;
5122     }
5123 #endif
5124 
operator =(std::nullptr_t)5125     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5126     {
5127       m_videoSessionKHR = {};
5128       return *this;
5129     }
5130 
5131 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5132     auto operator<=>( VideoSessionKHR const & ) const = default;
5133 #else
operator ==(VideoSessionKHR const & rhs) const5134     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5135     {
5136       return m_videoSessionKHR == rhs.m_videoSessionKHR;
5137     }
5138 
operator !=(VideoSessionKHR const & rhs) const5139     bool operator!=(VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5140     {
5141       return m_videoSessionKHR != rhs.m_videoSessionKHR;
5142     }
5143 
operator <(VideoSessionKHR const & rhs) const5144     bool operator<(VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5145     {
5146       return m_videoSessionKHR < rhs.m_videoSessionKHR;
5147     }
5148 #endif
5149 
operator VkVideoSessionKHR() const5150     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
5151     {
5152       return m_videoSessionKHR;
5153     }
5154 
operator bool() const5155     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5156     {
5157       return m_videoSessionKHR != VK_NULL_HANDLE;
5158     }
5159 
operator !() const5160     bool operator!() const VULKAN_HPP_NOEXCEPT
5161     {
5162       return m_videoSessionKHR == VK_NULL_HANDLE;
5163     }
5164 
5165   private:
5166     VkVideoSessionKHR m_videoSessionKHR = {};
5167   };
5168 
5169   template <>
5170   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
5171   {
5172     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
5173   };
5174 
5175 
5176 
5177   template <>
5178   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
5179   {
5180     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5181   };
5182 
5183   class DeferredOperationKHR
5184   {
5185   public:
5186     using CType = VkDeferredOperationKHR;
5187     using NativeType = VkDeferredOperationKHR;
5188 
5189     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
5190     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5191 
5192   public:
5193     VULKAN_HPP_CONSTEXPR DeferredOperationKHR() = default;
DeferredOperationKHR(std::nullptr_t)5194     VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5195     {}
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)5196     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
5197       : m_deferredOperationKHR( deferredOperationKHR )
5198     {}
5199 
5200 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDeferredOperationKHR deferredOperationKHR)5201     DeferredOperationKHR & operator=(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT
5202     {
5203       m_deferredOperationKHR = deferredOperationKHR;
5204       return *this;
5205     }
5206 #endif
5207 
operator =(std::nullptr_t)5208     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5209     {
5210       m_deferredOperationKHR = {};
5211       return *this;
5212     }
5213 
5214 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5215     auto operator<=>( DeferredOperationKHR const & ) const = default;
5216 #else
operator ==(DeferredOperationKHR const & rhs) const5217     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5218     {
5219       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
5220     }
5221 
operator !=(DeferredOperationKHR const & rhs) const5222     bool operator!=(DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5223     {
5224       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
5225     }
5226 
operator <(DeferredOperationKHR const & rhs) const5227     bool operator<(DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
5228     {
5229       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
5230     }
5231 #endif
5232 
operator VkDeferredOperationKHR() const5233     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
5234     {
5235       return m_deferredOperationKHR;
5236     }
5237 
operator bool() const5238     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5239     {
5240       return m_deferredOperationKHR != VK_NULL_HANDLE;
5241     }
5242 
operator !() const5243     bool operator!() const VULKAN_HPP_NOEXCEPT
5244     {
5245       return m_deferredOperationKHR == VK_NULL_HANDLE;
5246     }
5247 
5248   private:
5249     VkDeferredOperationKHR m_deferredOperationKHR = {};
5250   };
5251 
5252   template <>
5253   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
5254   {
5255     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
5256   };
5257 
5258 
5259 
5260   template <>
5261   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
5262   {
5263     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5264   };
5265 
5266 #if defined( VK_USE_PLATFORM_FUCHSIA )
5267   class BufferCollectionFUCHSIA
5268   {
5269   public:
5270     using CType = VkBufferCollectionFUCHSIA;
5271     using NativeType = VkBufferCollectionFUCHSIA;
5272 
5273     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
5274     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
5275 
5276   public:
5277     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
BufferCollectionFUCHSIA(std::nullptr_t)5278     VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5279     {}
BufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)5280     VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
5281       : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
5282     {}
5283 
5284 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA)5285     BufferCollectionFUCHSIA & operator=(VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA) VULKAN_HPP_NOEXCEPT
5286     {
5287       m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
5288       return *this;
5289     }
5290 #endif
5291 
operator =(std::nullptr_t)5292     BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5293     {
5294       m_bufferCollectionFUCHSIA = {};
5295       return *this;
5296     }
5297 
5298 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5299     auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
5300 #else
operator ==(BufferCollectionFUCHSIA const & rhs) const5301     bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5302     {
5303       return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
5304     }
5305 
operator !=(BufferCollectionFUCHSIA const & rhs) const5306     bool operator!=(BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5307     {
5308       return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
5309     }
5310 
operator <(BufferCollectionFUCHSIA const & rhs) const5311     bool operator<(BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
5312     {
5313       return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
5314     }
5315 #endif
5316 
operator VkBufferCollectionFUCHSIA() const5317     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
5318     {
5319       return m_bufferCollectionFUCHSIA;
5320     }
5321 
operator bool() const5322     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5323     {
5324       return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
5325     }
5326 
operator !() const5327     bool operator!() const VULKAN_HPP_NOEXCEPT
5328     {
5329       return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
5330     }
5331 
5332   private:
5333     VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
5334   };
5335 
5336   template <>
5337   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
5338   {
5339     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5340   };
5341 
5342 
5343   template <>
5344   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
5345   {
5346     using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
5347   };
5348 
5349 
5350   template <>
5351   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
5352   {
5353     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5354   };
5355 #endif /*VK_USE_PLATFORM_FUCHSIA*/
5356 
5357   class BufferView
5358   {
5359   public:
5360     using CType = VkBufferView;
5361     using NativeType = VkBufferView;
5362 
5363     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
5364     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
5365 
5366   public:
5367     VULKAN_HPP_CONSTEXPR BufferView() = default;
BufferView(std::nullptr_t)5368     VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5369     {}
BufferView(VkBufferView bufferView)5370     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
5371       : m_bufferView( bufferView )
5372     {}
5373 
5374 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkBufferView bufferView)5375     BufferView & operator=(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
5376     {
5377       m_bufferView = bufferView;
5378       return *this;
5379     }
5380 #endif
5381 
operator =(std::nullptr_t)5382     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5383     {
5384       m_bufferView = {};
5385       return *this;
5386     }
5387 
5388 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5389     auto operator<=>( BufferView const & ) const = default;
5390 #else
operator ==(BufferView const & rhs) const5391     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5392     {
5393       return m_bufferView == rhs.m_bufferView;
5394     }
5395 
operator !=(BufferView const & rhs) const5396     bool operator!=(BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5397     {
5398       return m_bufferView != rhs.m_bufferView;
5399     }
5400 
operator <(BufferView const & rhs) const5401     bool operator<(BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
5402     {
5403       return m_bufferView < rhs.m_bufferView;
5404     }
5405 #endif
5406 
operator VkBufferView() const5407     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
5408     {
5409       return m_bufferView;
5410     }
5411 
operator bool() const5412     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5413     {
5414       return m_bufferView != VK_NULL_HANDLE;
5415     }
5416 
operator !() const5417     bool operator!() const VULKAN_HPP_NOEXCEPT
5418     {
5419       return m_bufferView == VK_NULL_HANDLE;
5420     }
5421 
5422   private:
5423     VkBufferView m_bufferView = {};
5424   };
5425 
5426   template <>
5427   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
5428   {
5429     using Type = VULKAN_HPP_NAMESPACE::BufferView;
5430   };
5431 
5432 
5433   template <>
5434   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
5435   {
5436     using Type = VULKAN_HPP_NAMESPACE::BufferView;
5437   };
5438 
5439 
5440   template <>
5441   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
5442   {
5443     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5444   };
5445 
5446   class CommandPool
5447   {
5448   public:
5449     using CType = VkCommandPool;
5450     using NativeType = VkCommandPool;
5451 
5452     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
5453     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
5454 
5455   public:
5456     VULKAN_HPP_CONSTEXPR CommandPool() = default;
CommandPool(std::nullptr_t)5457     VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5458     {}
CommandPool(VkCommandPool commandPool)5459     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
5460       : m_commandPool( commandPool )
5461     {}
5462 
5463 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCommandPool commandPool)5464     CommandPool & operator=(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
5465     {
5466       m_commandPool = commandPool;
5467       return *this;
5468     }
5469 #endif
5470 
operator =(std::nullptr_t)5471     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5472     {
5473       m_commandPool = {};
5474       return *this;
5475     }
5476 
5477 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5478     auto operator<=>( CommandPool const & ) const = default;
5479 #else
operator ==(CommandPool const & rhs) const5480     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5481     {
5482       return m_commandPool == rhs.m_commandPool;
5483     }
5484 
operator !=(CommandPool const & rhs) const5485     bool operator!=(CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5486     {
5487       return m_commandPool != rhs.m_commandPool;
5488     }
5489 
operator <(CommandPool const & rhs) const5490     bool operator<(CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5491     {
5492       return m_commandPool < rhs.m_commandPool;
5493     }
5494 #endif
5495 
operator VkCommandPool() const5496     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
5497     {
5498       return m_commandPool;
5499     }
5500 
operator bool() const5501     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5502     {
5503       return m_commandPool != VK_NULL_HANDLE;
5504     }
5505 
operator !() const5506     bool operator!() const VULKAN_HPP_NOEXCEPT
5507     {
5508       return m_commandPool == VK_NULL_HANDLE;
5509     }
5510 
5511   private:
5512     VkCommandPool m_commandPool = {};
5513   };
5514 
5515   template <>
5516   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
5517   {
5518     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
5519   };
5520 
5521 
5522   template <>
5523   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
5524   {
5525     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
5526   };
5527 
5528 
5529   template <>
5530   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
5531   {
5532     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5533   };
5534 
5535   class PipelineCache
5536   {
5537   public:
5538     using CType = VkPipelineCache;
5539     using NativeType = VkPipelineCache;
5540 
5541     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
5542     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
5543 
5544   public:
5545     VULKAN_HPP_CONSTEXPR PipelineCache() = default;
PipelineCache(std::nullptr_t)5546     VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5547     {}
PipelineCache(VkPipelineCache pipelineCache)5548     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
5549       : m_pipelineCache( pipelineCache )
5550     {}
5551 
5552 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPipelineCache pipelineCache)5553     PipelineCache & operator=(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
5554     {
5555       m_pipelineCache = pipelineCache;
5556       return *this;
5557     }
5558 #endif
5559 
operator =(std::nullptr_t)5560     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5561     {
5562       m_pipelineCache = {};
5563       return *this;
5564     }
5565 
5566 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5567     auto operator<=>( PipelineCache const & ) const = default;
5568 #else
operator ==(PipelineCache const & rhs) const5569     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5570     {
5571       return m_pipelineCache == rhs.m_pipelineCache;
5572     }
5573 
operator !=(PipelineCache const & rhs) const5574     bool operator!=(PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5575     {
5576       return m_pipelineCache != rhs.m_pipelineCache;
5577     }
5578 
operator <(PipelineCache const & rhs) const5579     bool operator<(PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5580     {
5581       return m_pipelineCache < rhs.m_pipelineCache;
5582     }
5583 #endif
5584 
operator VkPipelineCache() const5585     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
5586     {
5587       return m_pipelineCache;
5588     }
5589 
operator bool() const5590     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5591     {
5592       return m_pipelineCache != VK_NULL_HANDLE;
5593     }
5594 
operator !() const5595     bool operator!() const VULKAN_HPP_NOEXCEPT
5596     {
5597       return m_pipelineCache == VK_NULL_HANDLE;
5598     }
5599 
5600   private:
5601     VkPipelineCache m_pipelineCache = {};
5602   };
5603 
5604   template <>
5605   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
5606   {
5607     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5608   };
5609 
5610 
5611   template <>
5612   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
5613   {
5614     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5615   };
5616 
5617 
5618   template <>
5619   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
5620   {
5621     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5622   };
5623 
5624   class CuFunctionNVX
5625   {
5626   public:
5627     using CType = VkCuFunctionNVX;
5628     using NativeType = VkCuFunctionNVX;
5629 
5630     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
5631     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
5632 
5633   public:
5634     VULKAN_HPP_CONSTEXPR CuFunctionNVX() = default;
CuFunctionNVX(std::nullptr_t)5635     VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5636     {}
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)5637     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5638       : m_cuFunctionNVX( cuFunctionNVX )
5639     {}
5640 
5641 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCuFunctionNVX cuFunctionNVX)5642     CuFunctionNVX & operator=(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT
5643     {
5644       m_cuFunctionNVX = cuFunctionNVX;
5645       return *this;
5646     }
5647 #endif
5648 
operator =(std::nullptr_t)5649     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5650     {
5651       m_cuFunctionNVX = {};
5652       return *this;
5653     }
5654 
5655 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5656     auto operator<=>( CuFunctionNVX const & ) const = default;
5657 #else
operator ==(CuFunctionNVX const & rhs) const5658     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5659     {
5660       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
5661     }
5662 
operator !=(CuFunctionNVX const & rhs) const5663     bool operator!=(CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5664     {
5665       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
5666     }
5667 
operator <(CuFunctionNVX const & rhs) const5668     bool operator<(CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5669     {
5670       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
5671     }
5672 #endif
5673 
operator VkCuFunctionNVX() const5674     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
5675     {
5676       return m_cuFunctionNVX;
5677     }
5678 
operator bool() const5679     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5680     {
5681       return m_cuFunctionNVX != VK_NULL_HANDLE;
5682     }
5683 
operator !() const5684     bool operator!() const VULKAN_HPP_NOEXCEPT
5685     {
5686       return m_cuFunctionNVX == VK_NULL_HANDLE;
5687     }
5688 
5689   private:
5690     VkCuFunctionNVX m_cuFunctionNVX = {};
5691   };
5692 
5693   template <>
5694   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
5695   {
5696     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5697   };
5698 
5699 
5700   template <>
5701   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
5702   {
5703     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5704   };
5705 
5706 
5707   template <>
5708   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
5709   {
5710     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5711   };
5712 
5713   class CuModuleNVX
5714   {
5715   public:
5716     using CType = VkCuModuleNVX;
5717     using NativeType = VkCuModuleNVX;
5718 
5719     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
5720     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
5721 
5722   public:
5723     VULKAN_HPP_CONSTEXPR CuModuleNVX() = default;
CuModuleNVX(std::nullptr_t)5724     VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5725     {}
CuModuleNVX(VkCuModuleNVX cuModuleNVX)5726     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5727       : m_cuModuleNVX( cuModuleNVX )
5728     {}
5729 
5730 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkCuModuleNVX cuModuleNVX)5731     CuModuleNVX & operator=(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT
5732     {
5733       m_cuModuleNVX = cuModuleNVX;
5734       return *this;
5735     }
5736 #endif
5737 
operator =(std::nullptr_t)5738     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5739     {
5740       m_cuModuleNVX = {};
5741       return *this;
5742     }
5743 
5744 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5745     auto operator<=>( CuModuleNVX const & ) const = default;
5746 #else
operator ==(CuModuleNVX const & rhs) const5747     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5748     {
5749       return m_cuModuleNVX == rhs.m_cuModuleNVX;
5750     }
5751 
operator !=(CuModuleNVX const & rhs) const5752     bool operator!=(CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5753     {
5754       return m_cuModuleNVX != rhs.m_cuModuleNVX;
5755     }
5756 
operator <(CuModuleNVX const & rhs) const5757     bool operator<(CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5758     {
5759       return m_cuModuleNVX < rhs.m_cuModuleNVX;
5760     }
5761 #endif
5762 
operator VkCuModuleNVX() const5763     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
5764     {
5765       return m_cuModuleNVX;
5766     }
5767 
operator bool() const5768     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5769     {
5770       return m_cuModuleNVX != VK_NULL_HANDLE;
5771     }
5772 
operator !() const5773     bool operator!() const VULKAN_HPP_NOEXCEPT
5774     {
5775       return m_cuModuleNVX == VK_NULL_HANDLE;
5776     }
5777 
5778   private:
5779     VkCuModuleNVX m_cuModuleNVX = {};
5780   };
5781 
5782   template <>
5783   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
5784   {
5785     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5786   };
5787 
5788 
5789   template <>
5790   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
5791   {
5792     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5793   };
5794 
5795 
5796   template <>
5797   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
5798   {
5799     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5800   };
5801 
5802   class DescriptorPool
5803   {
5804   public:
5805     using CType = VkDescriptorPool;
5806     using NativeType = VkDescriptorPool;
5807 
5808     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
5809     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
5810 
5811   public:
5812     VULKAN_HPP_CONSTEXPR DescriptorPool() = default;
DescriptorPool(std::nullptr_t)5813     VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5814     {}
DescriptorPool(VkDescriptorPool descriptorPool)5815     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5816       : m_descriptorPool( descriptorPool )
5817     {}
5818 
5819 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorPool descriptorPool)5820     DescriptorPool & operator=(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
5821     {
5822       m_descriptorPool = descriptorPool;
5823       return *this;
5824     }
5825 #endif
5826 
operator =(std::nullptr_t)5827     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5828     {
5829       m_descriptorPool = {};
5830       return *this;
5831     }
5832 
5833 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5834     auto operator<=>( DescriptorPool const & ) const = default;
5835 #else
operator ==(DescriptorPool const & rhs) const5836     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5837     {
5838       return m_descriptorPool == rhs.m_descriptorPool;
5839     }
5840 
operator !=(DescriptorPool const & rhs) const5841     bool operator!=(DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5842     {
5843       return m_descriptorPool != rhs.m_descriptorPool;
5844     }
5845 
operator <(DescriptorPool const & rhs) const5846     bool operator<(DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5847     {
5848       return m_descriptorPool < rhs.m_descriptorPool;
5849     }
5850 #endif
5851 
operator VkDescriptorPool() const5852     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
5853     {
5854       return m_descriptorPool;
5855     }
5856 
operator bool() const5857     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5858     {
5859       return m_descriptorPool != VK_NULL_HANDLE;
5860     }
5861 
operator !() const5862     bool operator!() const VULKAN_HPP_NOEXCEPT
5863     {
5864       return m_descriptorPool == VK_NULL_HANDLE;
5865     }
5866 
5867   private:
5868     VkDescriptorPool m_descriptorPool = {};
5869   };
5870 
5871   template <>
5872   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
5873   {
5874     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5875   };
5876 
5877 
5878   template <>
5879   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
5880   {
5881     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5882   };
5883 
5884 
5885   template <>
5886   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
5887   {
5888     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5889   };
5890 
5891   class DescriptorSetLayout
5892   {
5893   public:
5894     using CType = VkDescriptorSetLayout;
5895     using NativeType = VkDescriptorSetLayout;
5896 
5897     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
5898     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
5899 
5900   public:
5901     VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default;
DescriptorSetLayout(std::nullptr_t)5902     VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5903     {}
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)5904     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5905       : m_descriptorSetLayout( descriptorSetLayout )
5906     {}
5907 
5908 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDescriptorSetLayout descriptorSetLayout)5909     DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
5910     {
5911       m_descriptorSetLayout = descriptorSetLayout;
5912       return *this;
5913     }
5914 #endif
5915 
operator =(std::nullptr_t)5916     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5917     {
5918       m_descriptorSetLayout = {};
5919       return *this;
5920     }
5921 
5922 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
5923     auto operator<=>( DescriptorSetLayout const & ) const = default;
5924 #else
operator ==(DescriptorSetLayout const & rhs) const5925     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5926     {
5927       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
5928     }
5929 
operator !=(DescriptorSetLayout const & rhs) const5930     bool operator!=(DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5931     {
5932       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
5933     }
5934 
operator <(DescriptorSetLayout const & rhs) const5935     bool operator<(DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5936     {
5937       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
5938     }
5939 #endif
5940 
operator VkDescriptorSetLayout() const5941     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
5942     {
5943       return m_descriptorSetLayout;
5944     }
5945 
operator bool() const5946     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5947     {
5948       return m_descriptorSetLayout != VK_NULL_HANDLE;
5949     }
5950 
operator !() const5951     bool operator!() const VULKAN_HPP_NOEXCEPT
5952     {
5953       return m_descriptorSetLayout == VK_NULL_HANDLE;
5954     }
5955 
5956   private:
5957     VkDescriptorSetLayout m_descriptorSetLayout = {};
5958   };
5959 
5960   template <>
5961   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
5962   {
5963     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5964   };
5965 
5966 
5967   template <>
5968   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
5969   {
5970     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5971   };
5972 
5973 
5974   template <>
5975   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
5976   {
5977     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5978   };
5979 
5980   class Framebuffer
5981   {
5982   public:
5983     using CType = VkFramebuffer;
5984     using NativeType = VkFramebuffer;
5985 
5986     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
5987     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
5988 
5989   public:
5990     VULKAN_HPP_CONSTEXPR Framebuffer() = default;
Framebuffer(std::nullptr_t)5991     VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5992     {}
Framebuffer(VkFramebuffer framebuffer)5993     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
5994       : m_framebuffer( framebuffer )
5995     {}
5996 
5997 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkFramebuffer framebuffer)5998     Framebuffer & operator=(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
5999     {
6000       m_framebuffer = framebuffer;
6001       return *this;
6002     }
6003 #endif
6004 
operator =(std::nullptr_t)6005     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6006     {
6007       m_framebuffer = {};
6008       return *this;
6009     }
6010 
6011 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6012     auto operator<=>( Framebuffer const & ) const = default;
6013 #else
operator ==(Framebuffer const & rhs) const6014     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6015     {
6016       return m_framebuffer == rhs.m_framebuffer;
6017     }
6018 
operator !=(Framebuffer const & rhs) const6019     bool operator!=(Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6020     {
6021       return m_framebuffer != rhs.m_framebuffer;
6022     }
6023 
operator <(Framebuffer const & rhs) const6024     bool operator<(Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
6025     {
6026       return m_framebuffer < rhs.m_framebuffer;
6027     }
6028 #endif
6029 
operator VkFramebuffer() const6030     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
6031     {
6032       return m_framebuffer;
6033     }
6034 
operator bool() const6035     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6036     {
6037       return m_framebuffer != VK_NULL_HANDLE;
6038     }
6039 
operator !() const6040     bool operator!() const VULKAN_HPP_NOEXCEPT
6041     {
6042       return m_framebuffer == VK_NULL_HANDLE;
6043     }
6044 
6045   private:
6046     VkFramebuffer m_framebuffer = {};
6047   };
6048 
6049   template <>
6050   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
6051   {
6052     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6053   };
6054 
6055 
6056   template <>
6057   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
6058   {
6059     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
6060   };
6061 
6062 
6063   template <>
6064   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
6065   {
6066     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6067   };
6068 
6069   class IndirectCommandsLayoutNV
6070   {
6071   public:
6072     using CType = VkIndirectCommandsLayoutNV;
6073     using NativeType = VkIndirectCommandsLayoutNV;
6074 
6075     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
6076     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6077 
6078   public:
6079     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
IndirectCommandsLayoutNV(std::nullptr_t)6080     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6081     {}
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6082     VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
6083       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
6084     {}
6085 
6086 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)6087     IndirectCommandsLayoutNV & operator=(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT
6088     {
6089       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
6090       return *this;
6091     }
6092 #endif
6093 
operator =(std::nullptr_t)6094     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6095     {
6096       m_indirectCommandsLayoutNV = {};
6097       return *this;
6098     }
6099 
6100 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6101     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
6102 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const6103     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6104     {
6105       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
6106     }
6107 
operator !=(IndirectCommandsLayoutNV const & rhs) const6108     bool operator!=(IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6109     {
6110       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
6111     }
6112 
operator <(IndirectCommandsLayoutNV const & rhs) const6113     bool operator<(IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
6114     {
6115       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
6116     }
6117 #endif
6118 
operator VkIndirectCommandsLayoutNV() const6119     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
6120     {
6121       return m_indirectCommandsLayoutNV;
6122     }
6123 
operator bool() const6124     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6125     {
6126       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
6127     }
6128 
operator !() const6129     bool operator!() const VULKAN_HPP_NOEXCEPT
6130     {
6131       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
6132     }
6133 
6134   private:
6135     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
6136   };
6137 
6138   template <>
6139   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
6140   {
6141     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
6142   };
6143 
6144 
6145 
6146   template <>
6147   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
6148   {
6149     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6150   };
6151 
6152   class PrivateDataSlot
6153   {
6154   public:
6155     using CType = VkPrivateDataSlot;
6156     using NativeType = VkPrivateDataSlot;
6157 
6158     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
6159     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6160 
6161   public:
6162     VULKAN_HPP_CONSTEXPR PrivateDataSlot() = default;
PrivateDataSlot(std::nullptr_t)6163     VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6164     {}
PrivateDataSlot(VkPrivateDataSlot privateDataSlot)6165     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
6166       : m_privateDataSlot( privateDataSlot )
6167     {}
6168 
6169 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkPrivateDataSlot privateDataSlot)6170     PrivateDataSlot & operator=(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
6171     {
6172       m_privateDataSlot = privateDataSlot;
6173       return *this;
6174     }
6175 #endif
6176 
operator =(std::nullptr_t)6177     PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6178     {
6179       m_privateDataSlot = {};
6180       return *this;
6181     }
6182 
6183 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6184     auto operator<=>( PrivateDataSlot const & ) const = default;
6185 #else
operator ==(PrivateDataSlot const & rhs) const6186     bool operator==( PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
6187     {
6188       return m_privateDataSlot == rhs.m_privateDataSlot;
6189     }
6190 
operator !=(PrivateDataSlot const & rhs) const6191     bool operator!=(PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
6192     {
6193       return m_privateDataSlot != rhs.m_privateDataSlot;
6194     }
6195 
operator <(PrivateDataSlot const & rhs) const6196     bool operator<(PrivateDataSlot const & rhs ) const VULKAN_HPP_NOEXCEPT
6197     {
6198       return m_privateDataSlot < rhs.m_privateDataSlot;
6199     }
6200 #endif
6201 
operator VkPrivateDataSlot() const6202     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT
6203     {
6204       return m_privateDataSlot;
6205     }
6206 
operator bool() const6207     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6208     {
6209       return m_privateDataSlot != VK_NULL_HANDLE;
6210     }
6211 
operator !() const6212     bool operator!() const VULKAN_HPP_NOEXCEPT
6213     {
6214       return m_privateDataSlot == VK_NULL_HANDLE;
6215     }
6216 
6217   private:
6218     VkPrivateDataSlot m_privateDataSlot = {};
6219   };
6220 
6221   template <>
6222   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
6223   {
6224     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
6225   };
6226 
6227 
6228 
6229   template <>
6230   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
6231   {
6232     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6233   };
6234   using PrivateDataSlotEXT = PrivateDataSlot;
6235 
6236   class RenderPass
6237   {
6238   public:
6239     using CType = VkRenderPass;
6240     using NativeType = VkRenderPass;
6241 
6242     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
6243     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
6244 
6245   public:
6246     VULKAN_HPP_CONSTEXPR RenderPass() = default;
RenderPass(std::nullptr_t)6247     VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6248     {}
RenderPass(VkRenderPass renderPass)6249     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
6250       : m_renderPass( renderPass )
6251     {}
6252 
6253 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkRenderPass renderPass)6254     RenderPass & operator=(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
6255     {
6256       m_renderPass = renderPass;
6257       return *this;
6258     }
6259 #endif
6260 
operator =(std::nullptr_t)6261     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6262     {
6263       m_renderPass = {};
6264       return *this;
6265     }
6266 
6267 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6268     auto operator<=>( RenderPass const & ) const = default;
6269 #else
operator ==(RenderPass const & rhs) const6270     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6271     {
6272       return m_renderPass == rhs.m_renderPass;
6273     }
6274 
operator !=(RenderPass const & rhs) const6275     bool operator!=(RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6276     {
6277       return m_renderPass != rhs.m_renderPass;
6278     }
6279 
operator <(RenderPass const & rhs) const6280     bool operator<(RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
6281     {
6282       return m_renderPass < rhs.m_renderPass;
6283     }
6284 #endif
6285 
operator VkRenderPass() const6286     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
6287     {
6288       return m_renderPass;
6289     }
6290 
operator bool() const6291     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6292     {
6293       return m_renderPass != VK_NULL_HANDLE;
6294     }
6295 
operator !() const6296     bool operator!() const VULKAN_HPP_NOEXCEPT
6297     {
6298       return m_renderPass == VK_NULL_HANDLE;
6299     }
6300 
6301   private:
6302     VkRenderPass m_renderPass = {};
6303   };
6304 
6305   template <>
6306   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
6307   {
6308     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
6309   };
6310 
6311 
6312   template <>
6313   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
6314   {
6315     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
6316   };
6317 
6318 
6319   template <>
6320   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
6321   {
6322     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6323   };
6324 
6325   class Sampler
6326   {
6327   public:
6328     using CType = VkSampler;
6329     using NativeType = VkSampler;
6330 
6331     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
6332     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
6333 
6334   public:
6335     VULKAN_HPP_CONSTEXPR Sampler() = default;
Sampler(std::nullptr_t)6336     VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6337     {}
Sampler(VkSampler sampler)6338     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
6339       : m_sampler( sampler )
6340     {}
6341 
6342 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSampler sampler)6343     Sampler & operator=(VkSampler sampler) VULKAN_HPP_NOEXCEPT
6344     {
6345       m_sampler = sampler;
6346       return *this;
6347     }
6348 #endif
6349 
operator =(std::nullptr_t)6350     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6351     {
6352       m_sampler = {};
6353       return *this;
6354     }
6355 
6356 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6357     auto operator<=>( Sampler const & ) const = default;
6358 #else
operator ==(Sampler const & rhs) const6359     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6360     {
6361       return m_sampler == rhs.m_sampler;
6362     }
6363 
operator !=(Sampler const & rhs) const6364     bool operator!=(Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6365     {
6366       return m_sampler != rhs.m_sampler;
6367     }
6368 
operator <(Sampler const & rhs) const6369     bool operator<(Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
6370     {
6371       return m_sampler < rhs.m_sampler;
6372     }
6373 #endif
6374 
operator VkSampler() const6375     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
6376     {
6377       return m_sampler;
6378     }
6379 
operator bool() const6380     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6381     {
6382       return m_sampler != VK_NULL_HANDLE;
6383     }
6384 
operator !() const6385     bool operator!() const VULKAN_HPP_NOEXCEPT
6386     {
6387       return m_sampler == VK_NULL_HANDLE;
6388     }
6389 
6390   private:
6391     VkSampler m_sampler = {};
6392   };
6393 
6394   template <>
6395   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
6396   {
6397     using Type = VULKAN_HPP_NAMESPACE::Sampler;
6398   };
6399 
6400 
6401   template <>
6402   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
6403   {
6404     using Type = VULKAN_HPP_NAMESPACE::Sampler;
6405   };
6406 
6407 
6408   template <>
6409   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
6410   {
6411     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6412   };
6413 
6414   class SamplerYcbcrConversion
6415   {
6416   public:
6417     using CType = VkSamplerYcbcrConversion;
6418     using NativeType = VkSamplerYcbcrConversion;
6419 
6420     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
6421     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
6422 
6423   public:
6424     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
SamplerYcbcrConversion(std::nullptr_t)6425     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6426     {}
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)6427     VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
6428       : m_samplerYcbcrConversion( samplerYcbcrConversion )
6429     {}
6430 
6431 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)6432     SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
6433     {
6434       m_samplerYcbcrConversion = samplerYcbcrConversion;
6435       return *this;
6436     }
6437 #endif
6438 
operator =(std::nullptr_t)6439     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6440     {
6441       m_samplerYcbcrConversion = {};
6442       return *this;
6443     }
6444 
6445 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6446     auto operator<=>( SamplerYcbcrConversion const & ) const = default;
6447 #else
operator ==(SamplerYcbcrConversion const & rhs) const6448     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6449     {
6450       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
6451     }
6452 
operator !=(SamplerYcbcrConversion const & rhs) const6453     bool operator!=(SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6454     {
6455       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
6456     }
6457 
operator <(SamplerYcbcrConversion const & rhs) const6458     bool operator<(SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
6459     {
6460       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
6461     }
6462 #endif
6463 
operator VkSamplerYcbcrConversion() const6464     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
6465     {
6466       return m_samplerYcbcrConversion;
6467     }
6468 
operator bool() const6469     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6470     {
6471       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
6472     }
6473 
operator !() const6474     bool operator!() const VULKAN_HPP_NOEXCEPT
6475     {
6476       return m_samplerYcbcrConversion == VK_NULL_HANDLE;
6477     }
6478 
6479   private:
6480     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
6481   };
6482 
6483   template <>
6484   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
6485   {
6486     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6487   };
6488 
6489 
6490   template <>
6491   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
6492   {
6493     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6494   };
6495 
6496 
6497   template <>
6498   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
6499   {
6500     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6501   };
6502   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
6503 
6504   class ShaderModule
6505   {
6506   public:
6507     using CType = VkShaderModule;
6508     using NativeType = VkShaderModule;
6509 
6510     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
6511     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
6512 
6513   public:
6514     VULKAN_HPP_CONSTEXPR ShaderModule() = default;
ShaderModule(std::nullptr_t)6515     VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6516     {}
ShaderModule(VkShaderModule shaderModule)6517     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6518       : m_shaderModule( shaderModule )
6519     {}
6520 
6521 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkShaderModule shaderModule)6522     ShaderModule & operator=(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
6523     {
6524       m_shaderModule = shaderModule;
6525       return *this;
6526     }
6527 #endif
6528 
operator =(std::nullptr_t)6529     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6530     {
6531       m_shaderModule = {};
6532       return *this;
6533     }
6534 
6535 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6536     auto operator<=>( ShaderModule const & ) const = default;
6537 #else
operator ==(ShaderModule const & rhs) const6538     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6539     {
6540       return m_shaderModule == rhs.m_shaderModule;
6541     }
6542 
operator !=(ShaderModule const & rhs) const6543     bool operator!=(ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6544     {
6545       return m_shaderModule != rhs.m_shaderModule;
6546     }
6547 
operator <(ShaderModule const & rhs) const6548     bool operator<(ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6549     {
6550       return m_shaderModule < rhs.m_shaderModule;
6551     }
6552 #endif
6553 
operator VkShaderModule() const6554     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
6555     {
6556       return m_shaderModule;
6557     }
6558 
operator bool() const6559     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6560     {
6561       return m_shaderModule != VK_NULL_HANDLE;
6562     }
6563 
operator !() const6564     bool operator!() const VULKAN_HPP_NOEXCEPT
6565     {
6566       return m_shaderModule == VK_NULL_HANDLE;
6567     }
6568 
6569   private:
6570     VkShaderModule m_shaderModule = {};
6571   };
6572 
6573   template <>
6574   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
6575   {
6576     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6577   };
6578 
6579 
6580   template <>
6581   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
6582   {
6583     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6584   };
6585 
6586 
6587   template <>
6588   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
6589   {
6590     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6591   };
6592 
6593   class ValidationCacheEXT
6594   {
6595   public:
6596     using CType = VkValidationCacheEXT;
6597     using NativeType = VkValidationCacheEXT;
6598 
6599     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
6600     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
6601 
6602   public:
6603     VULKAN_HPP_CONSTEXPR ValidationCacheEXT() = default;
ValidationCacheEXT(std::nullptr_t)6604     VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6605     {}
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)6606     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6607       : m_validationCacheEXT( validationCacheEXT )
6608     {}
6609 
6610 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkValidationCacheEXT validationCacheEXT)6611     ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT
6612     {
6613       m_validationCacheEXT = validationCacheEXT;
6614       return *this;
6615     }
6616 #endif
6617 
operator =(std::nullptr_t)6618     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6619     {
6620       m_validationCacheEXT = {};
6621       return *this;
6622     }
6623 
6624 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6625     auto operator<=>( ValidationCacheEXT const & ) const = default;
6626 #else
operator ==(ValidationCacheEXT const & rhs) const6627     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6628     {
6629       return m_validationCacheEXT == rhs.m_validationCacheEXT;
6630     }
6631 
operator !=(ValidationCacheEXT const & rhs) const6632     bool operator!=(ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6633     {
6634       return m_validationCacheEXT != rhs.m_validationCacheEXT;
6635     }
6636 
operator <(ValidationCacheEXT const & rhs) const6637     bool operator<(ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6638     {
6639       return m_validationCacheEXT < rhs.m_validationCacheEXT;
6640     }
6641 #endif
6642 
operator VkValidationCacheEXT() const6643     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
6644     {
6645       return m_validationCacheEXT;
6646     }
6647 
operator bool() const6648     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6649     {
6650       return m_validationCacheEXT != VK_NULL_HANDLE;
6651     }
6652 
operator !() const6653     bool operator!() const VULKAN_HPP_NOEXCEPT
6654     {
6655       return m_validationCacheEXT == VK_NULL_HANDLE;
6656     }
6657 
6658   private:
6659     VkValidationCacheEXT m_validationCacheEXT = {};
6660   };
6661 
6662   template <>
6663   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
6664   {
6665     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6666   };
6667 
6668 
6669   template <>
6670   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
6671   {
6672     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6673   };
6674 
6675 
6676   template <>
6677   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
6678   {
6679     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6680   };
6681 
6682   class VideoSessionParametersKHR
6683   {
6684   public:
6685     using CType = VkVideoSessionParametersKHR;
6686     using NativeType = VkVideoSessionParametersKHR;
6687 
6688     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
6689     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6690 
6691   public:
6692     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
VideoSessionParametersKHR(std::nullptr_t)6693     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6694     {}
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)6695     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6696       : m_videoSessionParametersKHR( videoSessionParametersKHR )
6697     {}
6698 
6699 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)6700     VideoSessionParametersKHR & operator=(VkVideoSessionParametersKHR videoSessionParametersKHR) VULKAN_HPP_NOEXCEPT
6701     {
6702       m_videoSessionParametersKHR = videoSessionParametersKHR;
6703       return *this;
6704     }
6705 #endif
6706 
operator =(std::nullptr_t)6707     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6708     {
6709       m_videoSessionParametersKHR = {};
6710       return *this;
6711     }
6712 
6713 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6714     auto operator<=>( VideoSessionParametersKHR const & ) const = default;
6715 #else
operator ==(VideoSessionParametersKHR const & rhs) const6716     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6717     {
6718       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
6719     }
6720 
operator !=(VideoSessionParametersKHR const & rhs) const6721     bool operator!=(VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6722     {
6723       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
6724     }
6725 
operator <(VideoSessionParametersKHR const & rhs) const6726     bool operator<(VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6727     {
6728       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
6729     }
6730 #endif
6731 
operator VkVideoSessionParametersKHR() const6732     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
6733     {
6734       return m_videoSessionParametersKHR;
6735     }
6736 
operator bool() const6737     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6738     {
6739       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
6740     }
6741 
operator !() const6742     bool operator!() const VULKAN_HPP_NOEXCEPT
6743     {
6744       return m_videoSessionParametersKHR == VK_NULL_HANDLE;
6745     }
6746 
6747   private:
6748     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
6749   };
6750 
6751   template <>
6752   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
6753   {
6754     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6755   };
6756 
6757 
6758 
6759   template <>
6760   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
6761   {
6762     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6763   };
6764 
6765   class Queue
6766   {
6767   public:
6768     using CType = VkQueue;
6769     using NativeType = VkQueue;
6770 
6771     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
6772     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
6773 
6774   public:
6775     VULKAN_HPP_CONSTEXPR Queue() = default;
Queue(std::nullptr_t)6776     VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6777     {}
Queue(VkQueue queue)6778     Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT
6779       : m_queue( queue )
6780     {}
6781 
operator =(VkQueue queue)6782     Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
6783     {
6784       m_queue = queue;
6785       return *this;
6786     }
6787 
operator =(std::nullptr_t)6788     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6789     {
6790       m_queue = {};
6791       return *this;
6792     }
6793 
6794 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
6795     auto operator<=>( Queue const & ) const = default;
6796 #else
operator ==(Queue const & rhs) const6797     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6798     {
6799       return m_queue == rhs.m_queue;
6800     }
6801 
operator !=(Queue const & rhs) const6802     bool operator!=(Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6803     {
6804       return m_queue != rhs.m_queue;
6805     }
6806 
operator <(Queue const & rhs) const6807     bool operator<(Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6808     {
6809       return m_queue < rhs.m_queue;
6810     }
6811 #endif
6812 
6813   //=== VK_VERSION_1_0 ===
6814 
6815 
6816     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6817     VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6818 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6820     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6821 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6822 
6823 
6824 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6825     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6826     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6827 #else
6828     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6829     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6830 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6831 
6832 
6833     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6834     VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6837     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6838 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6839 
6840   //=== VK_VERSION_1_3 ===
6841 
6842 
6843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6844     VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6845 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6846     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6847     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6848 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6849 
6850   //=== VK_KHR_swapchain ===
6851 
6852 
6853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6854     VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6856     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6857     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6859 
6860   //=== VK_EXT_debug_utils ===
6861 
6862 
6863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6864     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6867     void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6869 
6870 
6871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6872     void endDebugUtilsLabelEXT( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6873 
6874 
6875     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6876     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6877 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6879     void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6881 
6882   //=== VK_NV_device_diagnostic_checkpoints ===
6883 
6884 
6885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6886     void getCheckpointDataNV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6888     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6889     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6890     template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CheckpointDataNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CheckpointDataNV>::value, int>::type = 0>
6891     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator> getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6892 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6893 
6894   //=== VK_INTEL_performance_query ===
6895 
6896 
6897 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6898     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6899     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6900 #else
6901     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6902     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6903 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6904 
6905   //=== VK_KHR_synchronization2 ===
6906 
6907 
6908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6909     VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount, const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits, VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6911     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6912     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6914 
6915 
6916     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6917     void getCheckpointData2NV( uint32_t * pCheckpointDataCount, VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6918 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6919     template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6920     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6921     template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CheckpointData2NVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CheckpointData2NV>::value, int>::type = 0>
6922     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator> getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6923 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6924 
operator VkQueue() const6925     operator VkQueue() const VULKAN_HPP_NOEXCEPT
6926     {
6927       return m_queue;
6928     }
6929 
operator bool() const6930     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6931     {
6932       return m_queue != VK_NULL_HANDLE;
6933     }
6934 
operator !() const6935     bool operator!() const VULKAN_HPP_NOEXCEPT
6936     {
6937       return m_queue == VK_NULL_HANDLE;
6938     }
6939 
6940   private:
6941     VkQueue m_queue = {};
6942   };
6943 
6944   template <>
6945   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
6946   {
6947     using Type = VULKAN_HPP_NAMESPACE::Queue;
6948   };
6949 
6950 
6951   template <>
6952   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
6953   {
6954     using Type = VULKAN_HPP_NAMESPACE::Queue;
6955   };
6956 
6957 
6958   template <>
6959   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
6960   {
6961     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6962   };
6963 
6964 #ifndef VULKAN_HPP_NO_SMART_HANDLE
6965   class Device;
6966   template <typename Dispatch>
6967   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
6968   {
6969   public:
6970     using deleter = ObjectDestroy<Device, Dispatch>;
6971   };
6972   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6973   template <typename Dispatch>
6974   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
6975   {
6976   public:
6977     using deleter = ObjectDestroy<Device, Dispatch>;
6978   };
6979   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6980   template <typename Dispatch>
6981   class UniqueHandleTraits<Buffer, Dispatch>
6982   {
6983   public:
6984     using deleter = ObjectDestroy<Device, Dispatch>;
6985   };
6986   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6987 #if defined( VK_USE_PLATFORM_FUCHSIA )
6988   template <typename Dispatch>
6989   class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
6990   {
6991   public:
6992     using deleter = ObjectDestroy<Device, Dispatch>;
6993   };
6994   using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6995 #endif /*VK_USE_PLATFORM_FUCHSIA*/
6996   template <typename Dispatch>
6997   class UniqueHandleTraits<BufferView, Dispatch>
6998   {
6999   public:
7000     using deleter = ObjectDestroy<Device, Dispatch>;
7001   };
7002   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7003   template <typename Dispatch>
7004   class UniqueHandleTraits<CommandBuffer, Dispatch>
7005   {
7006   public:
7007     using deleter = PoolFree<Device, CommandPool, Dispatch>;
7008   };
7009   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7010   template <typename Dispatch>
7011   class UniqueHandleTraits<CommandPool, Dispatch>
7012   {
7013   public:
7014     using deleter = ObjectDestroy<Device, Dispatch>;
7015   };
7016   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7017   template <typename Dispatch>
7018   class UniqueHandleTraits<CuFunctionNVX, Dispatch>
7019   {
7020   public:
7021     using deleter = ObjectDestroy<Device, Dispatch>;
7022   };
7023   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7024   template <typename Dispatch>
7025   class UniqueHandleTraits<CuModuleNVX, Dispatch>
7026   {
7027   public:
7028     using deleter = ObjectDestroy<Device, Dispatch>;
7029   };
7030   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7031   template <typename Dispatch>
7032   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
7033   {
7034   public:
7035     using deleter = ObjectDestroy<Device, Dispatch>;
7036   };
7037   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7038   template <typename Dispatch>
7039   class UniqueHandleTraits<DescriptorPool, Dispatch>
7040   {
7041   public:
7042     using deleter = ObjectDestroy<Device, Dispatch>;
7043   };
7044   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7045   template <typename Dispatch>
7046   class UniqueHandleTraits<DescriptorSet, Dispatch>
7047   {
7048   public:
7049     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
7050   };
7051   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7052   template <typename Dispatch>
7053   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
7054   {
7055   public:
7056     using deleter = ObjectDestroy<Device, Dispatch>;
7057   };
7058   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7059   template <typename Dispatch>
7060   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
7061   {
7062   public:
7063     using deleter = ObjectDestroy<Device, Dispatch>;
7064   };
7065   using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7066   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7067   template <typename Dispatch>
7068   class UniqueHandleTraits<DeviceMemory, Dispatch>
7069   {
7070   public:
7071     using deleter = ObjectFree<Device, Dispatch>;
7072   };
7073   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7074   template <typename Dispatch>
7075   class UniqueHandleTraits<Event, Dispatch>
7076   {
7077   public:
7078     using deleter = ObjectDestroy<Device, Dispatch>;
7079   };
7080   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7081   template <typename Dispatch>
7082   class UniqueHandleTraits<Fence, Dispatch>
7083   {
7084   public:
7085     using deleter = ObjectDestroy<Device, Dispatch>;
7086   };
7087   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7088   template <typename Dispatch>
7089   class UniqueHandleTraits<Framebuffer, Dispatch>
7090   {
7091   public:
7092     using deleter = ObjectDestroy<Device, Dispatch>;
7093   };
7094   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7095   template <typename Dispatch>
7096   class UniqueHandleTraits<Image, Dispatch>
7097   {
7098   public:
7099     using deleter = ObjectDestroy<Device, Dispatch>;
7100   };
7101   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7102   template <typename Dispatch>
7103   class UniqueHandleTraits<ImageView, Dispatch>
7104   {
7105   public:
7106     using deleter = ObjectDestroy<Device, Dispatch>;
7107   };
7108   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7109   template <typename Dispatch>
7110   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
7111   {
7112   public:
7113     using deleter = ObjectDestroy<Device, Dispatch>;
7114   };
7115   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7116   template <typename Dispatch>
7117   class UniqueHandleTraits<MicromapEXT, Dispatch>
7118   {
7119   public:
7120     using deleter = ObjectDestroy<Device, Dispatch>;
7121   };
7122   using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7123   template <typename Dispatch>
7124   class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
7125   {
7126   public:
7127     using deleter = ObjectDestroy<Device, Dispatch>;
7128   };
7129   using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7130   template <typename Dispatch>
7131   class UniqueHandleTraits<Pipeline, Dispatch>
7132   {
7133   public:
7134     using deleter = ObjectDestroy<Device, Dispatch>;
7135   };
7136   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7137   template <typename Dispatch>
7138   class UniqueHandleTraits<PipelineCache, Dispatch>
7139   {
7140   public:
7141     using deleter = ObjectDestroy<Device, Dispatch>;
7142   };
7143   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7144   template <typename Dispatch>
7145   class UniqueHandleTraits<PipelineLayout, Dispatch>
7146   {
7147   public:
7148     using deleter = ObjectDestroy<Device, Dispatch>;
7149   };
7150   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7151   template <typename Dispatch>
7152   class UniqueHandleTraits<PrivateDataSlot, Dispatch>
7153   {
7154   public:
7155     using deleter = ObjectDestroy<Device, Dispatch>;
7156   };
7157   using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7158   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7159   template <typename Dispatch>
7160   class UniqueHandleTraits<QueryPool, Dispatch>
7161   {
7162   public:
7163     using deleter = ObjectDestroy<Device, Dispatch>;
7164   };
7165   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7166   template <typename Dispatch>
7167   class UniqueHandleTraits<RenderPass, Dispatch>
7168   {
7169   public:
7170     using deleter = ObjectDestroy<Device, Dispatch>;
7171   };
7172   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7173   template <typename Dispatch>
7174   class UniqueHandleTraits<Sampler, Dispatch>
7175   {
7176   public:
7177     using deleter = ObjectDestroy<Device, Dispatch>;
7178   };
7179   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7180   template <typename Dispatch>
7181   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
7182   {
7183   public:
7184     using deleter = ObjectDestroy<Device, Dispatch>;
7185   };
7186   using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7187   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7188   template <typename Dispatch>
7189   class UniqueHandleTraits<Semaphore, Dispatch>
7190   {
7191   public:
7192     using deleter = ObjectDestroy<Device, Dispatch>;
7193   };
7194   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7195   template <typename Dispatch>
7196   class UniqueHandleTraits<ShaderModule, Dispatch>
7197   {
7198   public:
7199     using deleter = ObjectDestroy<Device, Dispatch>;
7200   };
7201   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7202   template <typename Dispatch>
7203   class UniqueHandleTraits<SwapchainKHR, Dispatch>
7204   {
7205   public:
7206     using deleter = ObjectDestroy<Device, Dispatch>;
7207   };
7208   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7209   template <typename Dispatch>
7210   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
7211   {
7212   public:
7213     using deleter = ObjectDestroy<Device, Dispatch>;
7214   };
7215   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7216   template <typename Dispatch>
7217   class UniqueHandleTraits<VideoSessionKHR, Dispatch>
7218   {
7219   public:
7220     using deleter = ObjectDestroy<Device, Dispatch>;
7221   };
7222   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7223   template <typename Dispatch>
7224   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
7225   {
7226   public:
7227     using deleter = ObjectDestroy<Device, Dispatch>;
7228   };
7229   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
7230 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7231 
7232   class Device
7233   {
7234   public:
7235     using CType = VkDevice;
7236     using NativeType = VkDevice;
7237 
7238     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
7239     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
7240 
7241   public:
7242     VULKAN_HPP_CONSTEXPR Device() = default;
Device(std::nullptr_t)7243     VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7244     {}
Device(VkDevice device)7245     Device( VkDevice device ) VULKAN_HPP_NOEXCEPT
7246       : m_device( device )
7247     {}
7248 
operator =(VkDevice device)7249     Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
7250     {
7251       m_device = device;
7252       return *this;
7253     }
7254 
operator =(std::nullptr_t)7255     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
7256     {
7257       m_device = {};
7258       return *this;
7259     }
7260 
7261 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
7262     auto operator<=>( Device const & ) const = default;
7263 #else
operator ==(Device const & rhs) const7264     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7265     {
7266       return m_device == rhs.m_device;
7267     }
7268 
operator !=(Device const & rhs) const7269     bool operator!=(Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7270     {
7271       return m_device != rhs.m_device;
7272     }
7273 
operator <(Device const & rhs) const7274     bool operator<(Device const & rhs ) const VULKAN_HPP_NOEXCEPT
7275     {
7276       return m_device < rhs.m_device;
7277     }
7278 #endif
7279 
7280   //=== VK_VERSION_1_0 ===
7281 
7282 
7283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7284     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7285 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7286     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7287     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7288 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7289 
7290 
7291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7292     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7293 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7294     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7295     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7296 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7297 
7298 
7299     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7300     void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7303     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7304 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7305 
7306 
7307 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7309     VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7310 #else
7311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7312     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7313 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7314 
7315 
7316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7317     VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7318 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7319     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7320     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7321 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7323     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7324 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7326 
7327 
7328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7329     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7331     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7332     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7333 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7334 
7335 
7336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7337     void ( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7338 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7340     void ( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7341 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7342 
7343 
7344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7345     VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags, void ** ppData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7346 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7347     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7348     VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize offset, VULKAN_HPP_NAMESPACE::DeviceSize size, VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7350 
7351 
7352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7353     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7354 
7355 
7356     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7357     VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7358 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7360     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7362 
7363 
7364     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7365     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7368     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7370 
7371 
7372     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7373     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7376     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7377 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7378 
7379 
7380 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7382     VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7383 #else
7384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7385     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7386 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7387 
7388 
7389 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7390     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7391     VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7392 #else
7393     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7394     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7395 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7396 
7397 
7398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7399     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7402     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7403 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7404 
7405 
7406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7407     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7410     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7411 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7412 
7413 
7414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7415     void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7417     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7418     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7419     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirementsAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements>::value, int>::type = 0>
7420     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7421 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7422 
7423 
7424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7425     VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7428     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7429 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7431     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7432 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7433 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7434 
7435 
7436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7437     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7438 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7440     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7441 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7442 
7443 
7444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7445     void destroy( VULKAN_HPP_NAMESPACE::Fence fence, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7446 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7448     void destroy( VULKAN_HPP_NAMESPACE::Fence fence, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7449 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7450 
7451 
7452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7453     VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence * pFences, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7456     typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7458 
7459 
7460 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7461     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7462     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7463 #else
7464     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7465     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7466 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7467 
7468 
7469     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7470     VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount, const VULKAN_HPP_NAMESPACE::Fence * pFences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, 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::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7474 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7475 
7476 
7477     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7478     VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7480     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7481     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7482 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7484     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7485 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7486 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7487 
7488 
7489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7490     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7492     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7493     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7494 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7495 
7496 
7497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7498     void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7499 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7500     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7501     void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7502 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7503 
7504 
7505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7506     VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Event * pEvent, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7507 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7509     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7510 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7512     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7513 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7514 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7515 
7516 
7517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7518     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7519 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7521     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7522 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7523 
7524 
7525     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7526     void destroy( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7527 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7528     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7529     void destroy( VULKAN_HPP_NAMESPACE::Event event, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7530 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7531 
7532 
7533 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7535     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7536 #else
7537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7538     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7539 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7540 
7541 
7542 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7544     VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7545 #else
7546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7547     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7548 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7549 
7550 
7551 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7552     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7553     VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7554 #else
7555     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7556     typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7557 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7558 
7559 
7560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7561     VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7563     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7564     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7565 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7566     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7567     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7568 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7570 
7571 
7572     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7573     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7574 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7576     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7577 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7578 
7579 
7580     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7581     void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7584     void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7585 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7586 
7587 
7588     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7589     VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void * pData, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7590 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7591     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7592     VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>> getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7593     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7594     VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7595 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7596 
7597 
7598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7599     VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Buffer * pBuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7600 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7601     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7602     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7603 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7604     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7605     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7606 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7607 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7608 
7609 
7610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7611     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7612 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7614     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7615 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7616 
7617 
7618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7619     void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7620 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7622     void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7623 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7624 
7625 
7626     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7627     VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::BufferView * pView, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7628 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7630     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7631 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7632     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7633     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7634 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7636 
7637 
7638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7639     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7641     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7642     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7643 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7644 
7645 
7646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7647     void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7648 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7650     void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7651 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7652 
7653 
7654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7655     VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Image * pImage, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7656 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7658     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7659 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7661     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7662 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7663 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7664 
7665 
7666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7667     void destroyImage( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7670     void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7672 
7673 
7674     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7675     void destroy( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7676 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7678     void destroy( VULKAN_HPP_NAMESPACE::Image image, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7679 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7680 
7681 
7682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7683     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7684 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7686     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7688 
7689 
7690     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7691     VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ImageView * pView, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7694     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7695 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7696     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7697     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7698 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7700 
7701 
7702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7703     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7704 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7706     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7707 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7708 
7709 
7710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7711     void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7713     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7714     void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7715 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7716 
7717 
7718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7719     VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7720 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7721     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7722     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7723 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7725     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7726 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7727 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7728 
7729 
7730     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7731     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7732 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7733     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7734     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7735 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7736 
7737 
7738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7739     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7740 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7741     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7742     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7743 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7744 
7745 
7746     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7747     VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7750     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7751 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7753     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7754 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7755 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7756 
7757 
7758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7759     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7762     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7763 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7764 
7765 
7766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7767     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7770     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7771 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7772 
7773 
7774     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7775     VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, size_t * pDataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7776 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7777     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7778     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7779     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
7780     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7781 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7782 
7783 
7784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7785     VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7787     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7788     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7789 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7790 
7791 
7792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7793     VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7794 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7795     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7796     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7797     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
7798     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7800     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7801 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
7803     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
7805     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7806     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7807     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7808 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7809 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7810 
7811 
7812     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7813     VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7814 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7815     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7816     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7817     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
7818     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7820     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7821 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7822     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
7823     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
7825     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7826     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7827     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 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 
7832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7833     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7835     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7836     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7838 
7839 
7840     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7841     void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7844     void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7845 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7846 
7847 
7848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7849     VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7850 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7851     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7852     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7853 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7855     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7856 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7857 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7858 
7859 
7860     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7861     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7862 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7864     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7865 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7866 
7867 
7868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7869     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7872     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7873 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7874 
7875 
7876     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7877     VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Sampler * pSampler, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7878 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7880     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7881 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7883     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7884 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7886 
7887 
7888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7889     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7890 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7892     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7894 
7895 
7896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7897     void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7900     void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7902 
7903 
7904     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7905     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7906 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7907     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7908     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7909 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7911     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7912 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7914 
7915 
7916     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7917     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7918 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7919     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7920     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7921 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7922 
7923 
7924     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7925     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7926 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7927     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7928     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7929 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7930 
7931 
7932     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7933     VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7934 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7936     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7937 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7938     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7939     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7940 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7941 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7942 
7943 
7944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7945     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7948     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7950 
7951 
7952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7953     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7956     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7957 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7958 
7959 
7960 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7961     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7962     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7963 #else
7964     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7965     void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7966 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7967 
7968 
7969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7970     VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo, VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7971 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7972     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7973     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7974     template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = DescriptorSetAllocator, typename std::enable_if<std::is_same<typename B0::value_type, DescriptorSet>::value, int>::type = 0>
7975     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7976 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
7978     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>, typename B0 = DescriptorSetAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value, int>::type = 0>
7980     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7981 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
7982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7983 
7984 
7985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7986     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7987 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7988     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7989     void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7990 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7991 
7992 
7993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7994     Result ( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7995 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7997     void ( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7998 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
7999 
8000 
8001     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8002     void updateDescriptorSets( uint32_t descriptorWriteCount, const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites, uint32_t descriptorCopyCount, const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8003 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8005     void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8006 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8007 
8008 
8009     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8010     VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8012     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8013     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8014 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8015     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8016     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8017 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8018 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8019 
8020 
8021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8022     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8023 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8025     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8027 
8028 
8029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8030     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8031 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8032     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8033     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8034 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8035 
8036 
8037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8038     VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8039 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8041     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8042 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8044     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8045 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8046 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8047 
8048 
8049     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8050     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8051 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8052     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8053     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8054 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8055 
8056 
8057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8058     void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8061     void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8062 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8063 
8064 
8065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8066     void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, VULKAN_HPP_NAMESPACE::Extent2D * pGranularity, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8069     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8070 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8071 
8072 
8073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8074     VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8075 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8076     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8077     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8078 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8080     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8081 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8083 
8084 
8085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8086     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8087 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8089     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8091 
8092 
8093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8094     void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8095 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8096     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8097     void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8098 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8099 
8100 
8101 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8102     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8103     VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8104 #else
8105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8106     typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8107 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8108 
8109 
8110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8111     VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo, VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8112 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8113     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8114     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8115     template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = CommandBufferAllocator, typename std::enable_if<std::is_same<typename B0::value_type, CommandBuffer>::value, int>::type = 0>
8116     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8117 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8118     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
8119     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>, typename B0 = CommandBufferAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value, int>::type = 0>
8121     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8122 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8123 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8124 
8125 
8126     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8127     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8130     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8131 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8132 
8133 
8134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8135     void ( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, uint32_t commandBufferCount, const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8136 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8138     void ( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8139 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8140 
8141   //=== VK_VERSION_1_1 ===
8142 
8143 
8144     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8145     VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8146 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8148     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8149 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8150 
8151 
8152     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8153     VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8155     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8156     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8157 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8158 
8159 
8160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8161     void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8163     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8164     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8165 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8166 
8167 
8168     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8169     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8172     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8173     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8174     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8175 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8176 
8177 
8178     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8179     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8180 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8181     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8182     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8183     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8184     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8185 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8186 
8187 
8188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8189     void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8190 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8191     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8192     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8193     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
8194     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8196 
8197 
8198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8199     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8200 
8201 
8202     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8203     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo, VULKAN_HPP_NAMESPACE::Queue * pQueue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8204 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8206     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8207 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8208 
8209 
8210     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8211     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, 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     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8215 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8216     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8217     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8218 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8219 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8220 
8221 
8222     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8223     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, 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 destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8227 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8228 
8229 
8230     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8231     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8233     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8234     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8236 
8237 
8238     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8239     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8240 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8241     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8242     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8243 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8244     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8245     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8246 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8247 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8248 
8249 
8250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8251     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8252 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8253     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8254     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8255 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8256 
8257 
8258     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8259     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, 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 destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8263 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8264 
8265 
8266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8267     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8269     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8270     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8271 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8272 
8273 
8274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8275     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8278     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8279     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8280     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8281 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8282 
8283   //=== VK_VERSION_1_2 ===
8284 
8285 
8286     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8287     VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8288 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8289     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8290     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8291 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8293     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8294 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8295 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8296 
8297 
8298     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8299     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8300 
8301 
8302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8303     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8306     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8307 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8308 
8309 
8310     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8311     VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8312 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8313     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8314     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8315 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8316 
8317 
8318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8319     VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8322     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8324 
8325 
8326     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8327     DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8328 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8330     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8331 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8332 
8333 
8334     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8335     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8336 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8337     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8338     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8339 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8340 
8341 
8342     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8343     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8344 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8345     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8346     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8348 
8349   //=== VK_VERSION_1_3 ===
8350 
8351 
8352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8353     VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8356     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8357 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8358     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8359     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8360 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8361 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8362 
8363 
8364     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8365     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8368     void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8370 
8371 
8372     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8373     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8376     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8377 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8378 
8379 
8380 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8382     VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8383 #else
8384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8385     typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8386 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8387 
8388 
8389     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8390     void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8391 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8393     VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8394 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8395 
8396 
8397     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8398     void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8399 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8400     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8401     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8402     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8403     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8405 
8406 
8407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8408     void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8409 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8410     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8411     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8412     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8413     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8414 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8415 
8416 
8417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8418     void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8419 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8420     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8421     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8422     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
8423     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8424 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8425 
8426   //=== VK_KHR_swapchain ===
8427 
8428 
8429     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8430     VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8431 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8433     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8434 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8436     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8437 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8438 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8439 
8440 
8441     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8442     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8444     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8445     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8447 
8448 
8449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8450     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8452     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8453     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8454 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8455 
8456 
8457     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8458     VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pSwapchainImageCount, VULKAN_HPP_NAMESPACE::Image * pSwapchainImages, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8459 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8460     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8461     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8462     template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ImageAllocator, typename std::enable_if<std::is_same<typename B1::value_type, Image>::value, int>::type = 0>
8463     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Image, ImageAllocator>>::type getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8464 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8465 
8466 
8467     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8468     VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence, uint32_t * pImageIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8471     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8472 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8473 
8474 
8475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8476     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8477 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8479     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8480 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8481 
8482 
8483     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8484     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8485 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8487     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8489 
8490 
8491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8492     VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8494     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8495     VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8497 
8498   //=== VK_KHR_display_swapchain ===
8499 
8500 
8501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8502     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8503 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8504     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8505     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8506     template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = SwapchainKHRAllocator, typename std::enable_if<std::is_same<typename B0::value_type, SwapchainKHR>::value, int>::type = 0>
8507     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8508     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8509     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8510 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
8512     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>, typename B0 = SwapchainKHRAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value, int>::type = 0>
8514     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8515     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8516     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8517 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8518 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8519 
8520   //=== VK_EXT_debug_marker ===
8521 
8522 
8523     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8524     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8525 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8526     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8527     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8528 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8529 
8530 
8531     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8532     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8533 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8535     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8536 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8537 
8538   //=== VK_KHR_video_queue ===
8539 
8540 
8541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8542     VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8543 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8544     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8545     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8546 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8548     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8549 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8550 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8551 
8552 
8553     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8554     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8555 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8556     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8557     void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8558 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8559 
8560 
8561     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8562     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8565     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8566 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8567 
8568 
8569     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8570     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t * pMemoryRequirementsCount, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8571 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8572     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8573     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8574     template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = VideoSessionMemoryRequirementsKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, VideoSessionMemoryRequirementsKHR>::value, int>::type = 0>
8575     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator>>::type getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8576 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8577 
8578 
8579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8580     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8581 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8583     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8584 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8585 
8586 
8587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8588     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8590     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8591     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8592 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8594     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8595 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8596 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8597 
8598 
8599     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8600     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8603     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8604 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8605 
8606 
8607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8608     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8609 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8611     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8612 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8613 
8614 
8615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8616     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8617 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8618     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8619     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8620 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8621 
8622   //=== VK_NVX_binary_import ===
8623 
8624 
8625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8626     VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8629     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8630 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8631     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8632     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8633 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8634 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8635 
8636 
8637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8638     VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8639 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8640     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8641     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8642 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8644     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8645 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8646 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8647 
8648 
8649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8650     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8651 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8653     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8654 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8655 
8656 
8657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8658     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8659 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8661     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8662 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8663 
8664 
8665     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8666     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8667 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8668     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8669     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8670 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8671 
8672 
8673     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8674     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8675 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8677     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8678 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8679 
8680   //=== VK_NVX_image_view_handle ===
8681 
8682 
8683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8684     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8685 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8687     uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8688 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8689 
8690 
8691     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8692     VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8693 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8695     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8696 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8697 
8698   //=== VK_AMD_shader_info ===
8699 
8700 
8701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8702     VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, size_t * pInfoSize, void * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8703 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8704     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8705     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8706     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
8707     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8708 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8709 
8710 #if defined( VK_USE_PLATFORM_WIN32_KHR )
8711   //=== VK_NV_external_memory_win32 ===
8712 
8713 
8714     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8715     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8716 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8718     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8719 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8720 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
8721 
8722   //=== VK_KHR_device_group ===
8723 
8724 
8725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8726     void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8728     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8729     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8731 
8732   //=== VK_KHR_maintenance1 ===
8733 
8734 
8735     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8736     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8737 
8738 #if defined( VK_USE_PLATFORM_WIN32_KHR )
8739   //=== VK_KHR_external_memory_win32 ===
8740 
8741 
8742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8743     VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8745     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8746     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8747 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8748 
8749 
8750     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8751     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8752 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8753     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8754     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8755 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8756 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
8757 
8758   //=== VK_KHR_external_memory_fd ===
8759 
8760 
8761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8762     VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8763 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8764     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8765     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8766 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8767 
8768 
8769     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8770     VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8771 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8772     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8773     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8774 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8775 
8776 #if defined( VK_USE_PLATFORM_WIN32_KHR )
8777   //=== VK_KHR_external_semaphore_win32 ===
8778 
8779 
8780     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8781     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8783     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8784     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8785 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8786 
8787 
8788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8789     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, 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     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8794 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
8795 
8796   //=== VK_KHR_external_semaphore_fd ===
8797 
8798 
8799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8800     VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8803     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8804 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8805 
8806 
8807     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8808     VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8809 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8811     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8812 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8813 
8814   //=== VK_KHR_descriptor_update_template ===
8815 
8816 
8817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8818     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8820     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8821     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8822 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8824     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8825 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8826 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8827 
8828 
8829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8830     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8831 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8833     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8834 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8835 
8836 
8837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8838     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8839 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8840     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8841     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8842 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8843 
8844   //=== VK_EXT_display_control ===
8845 
8846 
8847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8848     VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8851     typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8852 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8853 
8854 
8855     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8856     VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8857 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8858     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8859     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8860 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8862     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8863 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8864 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8865 
8866 
8867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8868     VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Fence * pFence, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8869 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8870     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8871     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8872 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8873     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8874     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8875 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8876 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8877 
8878 
8879     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8880     VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, uint64_t * pCounterValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8881 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8883     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8884 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8885 
8886   //=== VK_GOOGLE_display_timing ===
8887 
8888 
8889     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8890     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8892     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8893     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8894 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8895 
8896 
8897     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8898     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint32_t * pPresentationTimingCount, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8900     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8901     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8902     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PastPresentationTimingGOOGLEAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
8903     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8904 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8905 
8906   //=== VK_EXT_hdr_metadata ===
8907 
8908 
8909     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8910     void setHdrMetadataEXT( uint32_t swapchainCount, const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains, const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8911 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8913     void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
8914 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8915 
8916   //=== VK_KHR_create_renderpass2 ===
8917 
8918 
8919     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8920     VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8921 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8923     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8924 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8925     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8926     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8927 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
8928 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8929 
8930   //=== VK_KHR_shared_presentable_image ===
8931 
8932 
8933 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8935     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8936 #else
8937     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8938     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8939 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8940 
8941 #if defined( VK_USE_PLATFORM_WIN32_KHR )
8942   //=== VK_KHR_external_fence_win32 ===
8943 
8944 
8945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8946     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8949     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8951 
8952 
8953     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8954     VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8955 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8957     VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8958 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8959 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
8960 
8961   //=== VK_KHR_external_fence_fd ===
8962 
8963 
8964     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8965     VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8966 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8967     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8968     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8970 
8971 
8972     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8973     VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo, int * pFd, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8974 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8976     VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8977 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8978 
8979   //=== VK_KHR_performance_query ===
8980 
8981 
8982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8983     VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8984 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8985     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8986     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8987 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8988 
8989 
8990     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8991     void releaseProfilingLockKHR( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8992 
8993   //=== VK_EXT_debug_utils ===
8994 
8995 
8996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8997     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8998 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9000     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9001 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9002 
9003 
9004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9005     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9006 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9008     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9009 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9010 
9011 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
9012   //=== VK_ANDROID_external_memory_android_hardware_buffer ===
9013 
9014 
9015     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9016     VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties, 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 typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9020     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9021     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9022 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9023 
9024 
9025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9026     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, struct AHardwareBuffer ** pBuffer, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9028     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9029     VULKAN_HPP_NODISCARD typename ResultValueType<struct AHardwareBuffer *>::type getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9030 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9031 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
9032 
9033   //=== VK_KHR_get_memory_requirements2 ===
9034 
9035 
9036     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9037     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9040     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9041     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9042     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9044 
9045 
9046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9047     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9049     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9050     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9051     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9052     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9053 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9054 
9055 
9056     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9057     void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9059     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9060     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9061     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
9062     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9063 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9064 
9065   //=== VK_KHR_acceleration_structure ===
9066 
9067 
9068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9069     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9070 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9071     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9072     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9073 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9075     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9076 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9078 
9079 
9080     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9081     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9083     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9084     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9086 
9087 
9088     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9089     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9090 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9091     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9092     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9094 
9095 
9096     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9097     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9100     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9102 
9103 
9104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9105     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9107     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9108     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9109 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9110 
9111 
9112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9113     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9116     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9117 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9118 
9119 
9120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9121     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9122 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9124     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9126 
9127 
9128     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9129     VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void * pData, size_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9131     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9132     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9133     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9134     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeAccelerationStructuresPropertyKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9135 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9136 
9137 
9138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9139     DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9141     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9142     VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9143 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9144 
9145 
9146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9147     void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9150     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9151 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9152 
9153 
9154     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9155     void getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, const uint32_t * pMaxPrimitiveCounts, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9156 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9157     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9158     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
9159 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9160 
9161   //=== VK_KHR_sampler_ycbcr_conversion ===
9162 
9163 
9164     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9165     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9168     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9169 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9170     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9171     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9172 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9174 
9175 
9176     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9177     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9178 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9179     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9180     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9181 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9182 
9183   //=== VK_KHR_bind_memory2 ===
9184 
9185 
9186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9187     VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9188 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9189     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9190     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9191 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9192 
9193 
9194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9195     VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9197     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9198     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9200 
9201   //=== VK_EXT_image_drm_format_modifier ===
9202 
9203 
9204     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9205     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9206 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9207     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9208     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9209 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9210 
9211   //=== VK_EXT_validation_cache ===
9212 
9213 
9214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9215     VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9216 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9218     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9219 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9221     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9222 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9223 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9224 
9225 
9226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9227     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9228 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9229     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9230     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9231 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9232 
9233 
9234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9235     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9238     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9239 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9240 
9241 
9242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9243     VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches, 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<void>::type mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9247 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9248 
9249 
9250     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9251     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, size_t * pDataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9252 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9253     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9254     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9255     template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Uint8_tAllocator, typename std::enable_if<std::is_same<typename B1::value_type, uint8_t>::value, int>::type = 0>
9256     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9258 
9259   //=== VK_NV_ray_tracing ===
9260 
9261 
9262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9263     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9264 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9266     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9267 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9269     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9270 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9271 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9272 
9273 
9274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9275     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9278     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9280 
9281 
9282     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9283     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9284 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9285     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9286     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9288 
9289 
9290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9291     void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9292 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9293     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9294     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9295     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9296     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9297 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9298 
9299 
9300     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9301     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9302 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9304     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9305 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9306 
9307 
9308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9309     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9311     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9312     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9313     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
9314     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9316     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9317 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9319     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9320     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
9321     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9323     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9324 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9325 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9326 
9327 
9328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9329     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9331     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9332     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9333     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9334     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9335 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9336 
9337 
9338     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9339     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9341     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9342     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9343     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9344     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9345 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9346 
9347 
9348 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9350     VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9351 #else
9352     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9353     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9354 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9355 
9356   //=== VK_KHR_maintenance3 ===
9357 
9358 
9359     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9360     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9361 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9362     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9363     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9364     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9365     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9366 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9367 
9368   //=== VK_EXT_external_memory_host ===
9369 
9370 
9371     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9372     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9373 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9375     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9376 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9377 
9378   //=== VK_EXT_calibrated_timestamps ===
9379 
9380 
9381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9382     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount, const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos, uint64_t * pTimestamps, uint64_t * pMaxDeviation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9383 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9384     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9385     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9386     template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = Uint64_tAllocator, typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type = 0>
9387     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, Uint64_tAllocator & uint64_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9389     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<uint64_t, uint64_t>>::type getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9390 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9391 
9392   //=== VK_KHR_timeline_semaphore ===
9393 
9394 
9395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9396     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, uint64_t * pValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9399     VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9400 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9401 
9402 
9403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9404     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9405 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9407     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9408 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9409 
9410 
9411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9412     VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9415     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9417 
9418   //=== VK_INTEL_performance_query ===
9419 
9420 
9421     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9422     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9423 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9425     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9426 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9427 
9428 
9429     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9430     void uninitializePerformanceApiINTEL( Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9431 
9432 
9433     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9434     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9435 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9437     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9438 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9440     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9441 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9442 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9443 
9444 
9445 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9446     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9447     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9448 #else
9449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9450     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9451 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9452 
9453 
9454 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9455     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9456     VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9457 #else
9458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9459     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9460 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9461 
9462 
9463     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9464     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9465 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9467     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9468 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9469 
9470   //=== VK_AMD_display_native_hdr ===
9471 
9472 
9473     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9474     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain, VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9475 
9476   //=== VK_EXT_buffer_device_address ===
9477 
9478 
9479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9480     DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9483     VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9484 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9485 
9486   //=== VK_KHR_present_wait ===
9487 
9488 
9489 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9490     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9491     VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9492 #else
9493     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9494     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9495 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9496 
9497 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9498   //=== VK_EXT_full_screen_exclusive ===
9499 
9500 
9501 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9503     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9504 #else
9505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9506     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9507 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9508 
9509 
9510 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9512     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9513 #else
9514     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9515     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9516 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9517 
9518 
9519     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9520     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9523     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9524 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9525 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
9526 
9527   //=== VK_KHR_buffer_device_address ===
9528 
9529 
9530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9531     DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, 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_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9535 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9536 
9537 
9538     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9539     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9540 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9541     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9542     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9543 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9544 
9545 
9546     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9547     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9548 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9550     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9551 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9552 
9553   //=== VK_EXT_host_query_reset ===
9554 
9555 
9556     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9557     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9558 
9559   //=== VK_KHR_deferred_host_operations ===
9560 
9561 
9562     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9563     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9566     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9567 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9569     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type createDeferredOperationKHRUnique( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9570 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9571 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9572 
9573 
9574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9575     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9578     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9579 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9580 
9581 
9582     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9583     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9584 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9585     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9586     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9587 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9588 
9589 
9590     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9591     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9592 
9593 
9594 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9595     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9596     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9597 #else
9598     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9599     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9600 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9601 
9602 
9603 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9604     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9605     VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9606 #else
9607     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9608     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9609 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9610 
9611   //=== VK_KHR_pipeline_executable_properties ===
9612 
9613 
9614     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9615     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, uint32_t * pExecutableCount, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9616 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9617     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9618     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9619     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PipelineExecutablePropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutablePropertiesKHR>::value, int>::type = 0>
9620     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo, PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9621 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9622 
9623 
9624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9625     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pStatisticCount, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9626 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9627     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9628     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9629     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PipelineExecutableStatisticKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableStatisticKHR>::value, int>::type = 0>
9630     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9631 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9632 
9633 
9634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9635     VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, uint32_t * pInternalRepresentationCount, VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9636 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9637     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9638     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9639     template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PipelineExecutableInternalRepresentationKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PipelineExecutableInternalRepresentationKHR>::value, int>::type = 0>
9640     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo, PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9642 
9643   //=== VK_EXT_swapchain_maintenance1 ===
9644 
9645 
9646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9647     VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo, 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     typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9651 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9652 
9653   //=== VK_NV_device_generated_commands ===
9654 
9655 
9656     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9657     void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9658 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9659     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9660     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9661     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9662     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9663 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9664 
9665 
9666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9667     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9668 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9670     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9671 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9673     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9674 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9676 
9677 
9678     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9679     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9682     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9683 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9684 
9685 
9686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9687     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9688 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9689     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9690     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9691 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9692 
9693   //=== VK_EXT_private_data ===
9694 
9695 
9696     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9697     VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9698 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9699     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9700     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>::type createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9701 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9703     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>>::type createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9704 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9706 
9707 
9708     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9709     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9710 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9712     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9713 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9714 
9715 
9716 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9718     VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9719 #else
9720     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9721     typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9722 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9723 
9724 
9725     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9726     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9728     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9729     VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9730 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9731 
9732 #if defined( VK_USE_PLATFORM_METAL_EXT )
9733   //=== VK_EXT_metal_objects ===
9734 
9735 
9736     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9737     void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9738 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9739     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9740     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9741     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9742     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9743 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9744 #endif /*VK_USE_PLATFORM_METAL_EXT*/
9745 
9746   //=== VK_EXT_descriptor_buffer ===
9747 
9748 
9749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9750     void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, VULKAN_HPP_NAMESPACE::DeviceSize * pLayoutSizeInBytes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9753     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9754 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9755 
9756 
9757     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9758     void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, VULKAN_HPP_NAMESPACE::DeviceSize * pOffset, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9759 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9761     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9763 
9764 
9765     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9766     void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9768     template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9769     VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9770 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9771 
9772 
9773     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9774     VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9775 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9776     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9777     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9778 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9779 
9780 
9781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9782     VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9783 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9784     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9785     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9786 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9787 
9788 
9789     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9790     VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9791 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9792     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9793     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9794 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9795 
9796 
9797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9798     VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9800     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9801     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9802 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9803 
9804 
9805     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9806     VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9807 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9808     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9809     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9810 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9811 
9812   //=== VK_EXT_image_compression_control ===
9813 
9814 
9815     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9816     void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT * pSubresource, VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT * pLayout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9817 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9818     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9819     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9820     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9821     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image, const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9822 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9823 
9824   //=== VK_EXT_device_fault ===
9825 
9826 
9827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9828     VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9829 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9831     VULKAN_HPP_NODISCARD ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>> getFaultInfoEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9833 
9834   //=== VK_KHR_ray_tracing_pipeline ===
9835 
9836 
9837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9838     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, uint32_t createInfoCount, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Pipeline * pPipelines, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9839 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9840     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9841     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9842     template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, Pipeline>::value, int>::type = 0>
9843     VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9844     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9845     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9846 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9848     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9849     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>, typename B0 = PipelineAllocator, typename std::enable_if<std::is_same<typename B0::value_type, UniqueHandle<Pipeline, Dispatch>>::value, int>::type = 0>
9850     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, PipelineAllocator & pipelineAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9851     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9852     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>> createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9853 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9854 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9855 
9856 
9857     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9858     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9859 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9860     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9861     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9862     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9863     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9864 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9865 
9866 
9867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9868     VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9869 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9870     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9871     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9872     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9873     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9874 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9875 
9876 
9877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9878     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9879 
9880 #if defined( VK_USE_PLATFORM_FUCHSIA )
9881   //=== VK_FUCHSIA_external_memory ===
9882 
9883 
9884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9885     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9887     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9888     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9889 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9890 
9891 
9892     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9893     VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9895     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9896     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9897 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9898 #endif /*VK_USE_PLATFORM_FUCHSIA*/
9899 
9900 #if defined( VK_USE_PLATFORM_FUCHSIA )
9901   //=== VK_FUCHSIA_external_semaphore ===
9902 
9903 
9904     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9905     VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9906 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9907     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9908     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9909 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9910 
9911 
9912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9913     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, zx_handle_t * pZirconHandle, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9916     VULKAN_HPP_NODISCARD typename ResultValueType<zx_handle_t>::type getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9917 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9918 #endif /*VK_USE_PLATFORM_FUCHSIA*/
9919 
9920 #if defined( VK_USE_PLATFORM_FUCHSIA )
9921   //=== VK_FUCHSIA_buffer_collection ===
9922 
9923 
9924     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9925     VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA * pCollection, 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 typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>::type createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9929 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9931     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>>::type createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9932 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
9933 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9934 
9935 
9936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9937     VULKAN_HPP_NODISCARD Result setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9939     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9940     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9941 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9942 
9943 
9944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9945     VULKAN_HPP_NODISCARD Result setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9948     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9949 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9950 
9951 
9952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9953     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9954 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9955     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9956     void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9957 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9958 
9959 
9960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9961     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9964     void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9965 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9966 
9967 
9968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9969     VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9970 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9972     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>::type getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9973 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9974 #endif /*VK_USE_PLATFORM_FUCHSIA*/
9975 
9976   //=== VK_HUAWEI_subpass_shading ===
9977 
9978 
9979     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9980     VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9981 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9983     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D> getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9984 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9985 
9986   //=== VK_NV_external_memory_rdma ===
9987 
9988 
9989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9990     VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, VULKAN_HPP_NAMESPACE::RemoteAddressNV * pAddress, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9991 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9993     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9994 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9995 
9996   //=== VK_EXT_pipeline_properties ===
9997 
9998 
9999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10000     VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT * pPipelineInfo, VULKAN_HPP_NAMESPACE::BaseOutStructure * pPipelineProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10003     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::BaseOutStructure>::type getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10005 
10006   //=== VK_EXT_opacity_micromap ===
10007 
10008 
10009     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10010     VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromap, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10012     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10013     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MicromapEXT>::type createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10014 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10015     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10016     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>>::type createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10017 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10018 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10019 
10020 
10021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10022     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10023 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10025     void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10026 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10027 
10028 
10029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10030     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10031 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10032     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10033     void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10034 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10035 
10036 
10037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10038     VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, uint32_t infoCount, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10039 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10041     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10043 
10044 
10045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10046     VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10047 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10048     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10049     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10050 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10051 
10052 
10053     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10054     VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10055 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10056     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10057     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10058 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10059 
10060 
10061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10062     VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10063 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10065     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10067 
10068 
10069     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10070     VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount, const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, void * pData, size_t stride, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10072     template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10073     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10074     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10075     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, VULKAN_HPP_NAMESPACE::QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10076 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10077 
10078 
10079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10080     void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT * pVersionInfo, VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10082     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10083     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10084 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10085 
10086 
10087     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10088     void getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pBuildInfo, VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT * pSizeInfo, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10090     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10091     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10092 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10093 
10094   //=== VK_EXT_pageable_device_local_memory ===
10095 
10096 
10097     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10098     void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory, float priority, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10099 
10100   //=== VK_KHR_maintenance4 ===
10101 
10102 
10103     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10104     void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10107     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10108     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10109     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10110 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10111 
10112 
10113     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10114     void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10115 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10117     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10118     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10119     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10120 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10121 
10122 
10123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10124     void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10126     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10127     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10128     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageMemoryRequirements2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageMemoryRequirements2>::value, int>::type = 0>
10129     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info, SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10130 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10131 
10132   //=== VK_VALVE_descriptor_set_host_mapping ===
10133 
10134 
10135     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10136     void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference, VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10137 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10139     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10140 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10141 
10142 
10143     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10144     void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void ** ppData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10145 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10147     VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10148 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10149 
10150   //=== VK_EXT_shader_module_identifier ===
10151 
10152 
10153     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10154     void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10157     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10158 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10159 
10160 
10161     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10162     void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo, VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10163 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10164     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10165     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10167 
10168   //=== VK_NV_optical_flow ===
10169 
10170 
10171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10172     VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV * pSession, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10173 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10174     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10175     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>::type createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10176 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10178     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>>::type createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10179 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10180 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10181 
10182 
10183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10184     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10185 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10187     void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10188 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10189 
10190 
10191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10192     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10194     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10195     void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10196 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10197 
10198 
10199 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10201     VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10202 #else
10203     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10204     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, VULKAN_HPP_NAMESPACE::ImageLayout layout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10205 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10206 
10207   //=== VK_QCOM_tile_properties ===
10208 
10209 
10210     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10211     VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, uint32_t * pPropertiesCount, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10213     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10214     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10215     template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = TilePropertiesQCOMAllocator, typename std::enable_if<std::is_same<typename B1::value_type, TilePropertiesQCOM>::value, int>::type = 0>
10216     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM, TilePropertiesQCOMAllocator>>::type getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10217 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10218 
10219 
10220     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10221     Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10222 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10223     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10224     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10226 
operator VkDevice() const10227     operator VkDevice() const VULKAN_HPP_NOEXCEPT
10228     {
10229       return m_device;
10230     }
10231 
operator bool() const10232     explicit operator bool() const VULKAN_HPP_NOEXCEPT
10233     {
10234       return m_device != VK_NULL_HANDLE;
10235     }
10236 
operator !() const10237     bool operator!() const VULKAN_HPP_NOEXCEPT
10238     {
10239       return m_device == VK_NULL_HANDLE;
10240     }
10241 
10242   private:
10243     VkDevice m_device = {};
10244   };
10245 
10246   template <>
10247   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
10248   {
10249     using Type = VULKAN_HPP_NAMESPACE::Device;
10250   };
10251 
10252 
10253   template <>
10254   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
10255   {
10256     using Type = VULKAN_HPP_NAMESPACE::Device;
10257   };
10258 
10259 
10260   template <>
10261   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
10262   {
10263     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10264   };
10265 
10266   class DisplayModeKHR
10267   {
10268   public:
10269     using CType = VkDisplayModeKHR;
10270     using NativeType = VkDisplayModeKHR;
10271 
10272     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
10273     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
10274 
10275   public:
10276     VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default;
DisplayModeKHR(std::nullptr_t)10277     VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10278     {}
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)10279     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
10280       : m_displayModeKHR( displayModeKHR )
10281     {}
10282 
10283 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
operator =(VkDisplayModeKHR displayModeKHR)10284     DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
10285     {
10286       m_displayModeKHR = displayModeKHR;
10287       return *this;
10288     }
10289 #endif
10290 
operator =(std::nullptr_t)10291     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10292     {
10293       m_displayModeKHR = {};
10294       return *this;
10295     }
10296 
10297 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
10298     auto operator<=>( DisplayModeKHR const & ) const = default;
10299 #else
operator ==(DisplayModeKHR const & rhs) const10300     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
10301     {
10302       return m_displayModeKHR == rhs.m_displayModeKHR;
10303     }
10304 
operator !=(DisplayModeKHR const & rhs) const10305     bool operator!=(DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
10306     {
10307       return m_displayModeKHR != rhs.m_displayModeKHR;
10308     }
10309 
operator <(DisplayModeKHR const & rhs) const10310     bool operator<(DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
10311     {
10312       return m_displayModeKHR < rhs.m_displayModeKHR;
10313     }
10314 #endif
10315 
operator VkDisplayModeKHR() const10316     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
10317     {
10318       return m_displayModeKHR;
10319     }
10320 
operator bool() const10321     explicit operator bool() const VULKAN_HPP_NOEXCEPT
10322     {
10323       return m_displayModeKHR != VK_NULL_HANDLE;
10324     }
10325 
operator !() const10326     bool operator!() const VULKAN_HPP_NOEXCEPT
10327     {
10328       return m_displayModeKHR == VK_NULL_HANDLE;
10329     }
10330 
10331   private:
10332     VkDisplayModeKHR m_displayModeKHR = {};
10333   };
10334 
10335   template <>
10336   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
10337   {
10338     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
10339   };
10340 
10341 
10342   template <>
10343   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
10344   {
10345     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
10346   };
10347 
10348 
10349   template <>
10350   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
10351   {
10352     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
10353   };
10354 
10355 #ifndef VULKAN_HPP_NO_SMART_HANDLE
10356   template <typename Dispatch>
10357   class UniqueHandleTraits<Device, Dispatch>
10358   {
10359   public:
10360     using deleter = ObjectDestroy<NoParent, Dispatch>;
10361   };
10362   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
10363 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10364 
10365   class PhysicalDevice
10366   {
10367   public:
10368     using CType = VkPhysicalDevice;
10369     using NativeType = VkPhysicalDevice;
10370 
10371     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
10372     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
10373 
10374   public:
10375     VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;
PhysicalDevice(std::nullptr_t)10376     VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10377     {}
PhysicalDevice(VkPhysicalDevice physicalDevice)10378     PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
10379       : m_physicalDevice( physicalDevice )
10380     {}
10381 
operator =(VkPhysicalDevice physicalDevice)10382     PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
10383     {
10384       m_physicalDevice = physicalDevice;
10385       return *this;
10386     }
10387 
operator =(std::nullptr_t)10388     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
10389     {
10390       m_physicalDevice = {};
10391       return *this;
10392     }
10393 
10394 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
10395     auto operator<=>( PhysicalDevice const & ) const = default;
10396 #else
operator ==(PhysicalDevice const & rhs) const10397     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
10398     {
10399       return m_physicalDevice == rhs.m_physicalDevice;
10400     }
10401 
operator !=(PhysicalDevice const & rhs) const10402     bool operator!=(PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
10403     {
10404       return m_physicalDevice != rhs.m_physicalDevice;
10405     }
10406 
operator <(PhysicalDevice const & rhs) const10407     bool operator<(PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
10408     {
10409       return m_physicalDevice < rhs.m_physicalDevice;
10410     }
10411 #endif
10412 
10413   //=== VK_VERSION_1_0 ===
10414 
10415 
10416     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10417     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10420     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10421 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10422 
10423 
10424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10425     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10428     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10429 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10430 
10431 
10432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10433     VULKAN_HPP_NODISCARD Result getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10434 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10436     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10437 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10438 
10439 
10440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10441     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10442 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10443     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10444     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10446 
10447 
10448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10449     void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10451     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10452     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10453     template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = QueueFamilyPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties>::value, int>::type = 0>
10454     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator> getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10456 
10457 
10458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10459     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10461     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10462     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10463 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10464 
10465 
10466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10467     VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Device * pDevice, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10469     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10470     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10471 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10472     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10473     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10474 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10475 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10476 
10477 
10478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10479     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10480 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10481     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10482     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10483     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ExtensionPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, ExtensionProperties>::value, int>::type = 0>
10484     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, ExtensionPropertiesAllocator & extensionPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10485 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10486 
10487 
10488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10489     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10491     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10492     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10493     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = LayerPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, LayerProperties>::value, int>::type = 0>
10494     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10495 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10496 
10497 
10498     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10499     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10500 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10501     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10502     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10503     template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageFormatPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties>::value, int>::type = 0>
10504     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageTiling tiling, SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10505 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10506 
10507   //=== VK_VERSION_1_1 ===
10508 
10509 
10510     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10511     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10512 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10514     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10515     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10516     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10517 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10518 
10519 
10520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10521     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, 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 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10525     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10526     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10528 
10529 
10530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10531     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10534     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10535     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10536     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10537 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10538 
10539 
10540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10541     VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10542 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10543     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10544     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10545     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10546     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10547 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10548 
10549 
10550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10551     void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10552 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10553     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10554     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10555     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = QueueFamilyProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties2>::value, int>::type = 0>
10556     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10557     template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10558     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10559     template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = StructureChainAllocator, typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
10560     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10561 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10562 
10563 
10564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10565     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10568     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10569     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10570     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10571 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10572 
10573 
10574     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10575     void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10577     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10578     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10579     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageFormatProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
10580     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10581 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10582 
10583 
10584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10585     void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10586 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10587     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10588     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10589 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10590 
10591 
10592     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10593     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10594 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10595     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10596     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10598 
10599 
10600     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10601     void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10604     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10605 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10606 
10607   //=== VK_VERSION_1_3 ===
10608 
10609 
10610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10611     VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10612 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10613     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10614     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10615     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceToolPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0>
10616     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10617 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10618 
10619   //=== VK_KHR_surface ===
10620 
10621 
10622     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10623     VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::Bool32 * pSupported, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10624 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10626     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10627 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10628 
10629 
10630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10631     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10632 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10634     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10636 
10637 
10638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10639     VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10641     template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10642     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10643     template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SurfaceFormatKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SurfaceFormatKHR>::value, int>::type = 0>
10644     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10645 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10646 
10647 
10648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10649     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10651     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10652     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10653     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PresentModeKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PresentModeKHR>::value, int>::type = 0>
10654     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10655 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10656 
10657   //=== VK_KHR_swapchain ===
10658 
10659 
10660     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10661     VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, uint32_t * pRectCount, VULKAN_HPP_NAMESPACE::Rect2D * pRects, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10662 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10663     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10664     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10665     template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = Rect2DAllocator, typename std::enable_if<std::is_same<typename B1::value_type, Rect2D>::value, int>::type = 0>
10666     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::Rect2D, Rect2DAllocator>>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10667 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10668 
10669   //=== VK_KHR_display ===
10670 
10671 
10672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10673     VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10674 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10675     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10676     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10677     template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayPropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
10678     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10679 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10680 
10681 
10682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10683     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10684 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10685     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10686     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10687     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayPlanePropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
10688     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10689 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10690 
10691 
10692     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10693     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t * pDisplayCount, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10694 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10695     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10696     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10697     template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayKHR>::value, int>::type = 0>
10698     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR, DisplayKHRAllocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10700 
10701 
10702     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10703     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10704 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10705     template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10706     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10707     template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayModePropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
10708     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10709 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10710 
10711 
10712     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10713     VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10715     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10716     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10717 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10718     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10719     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10720 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10721 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10722 
10723 
10724     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10725     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10728     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10729 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10730 
10731 #if defined( VK_USE_PLATFORM_XLIB_KHR )
10732   //=== VK_KHR_xlib_surface ===
10733 
10734 
10735     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10736     Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10737 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10739     VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10740 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10741 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
10742 
10743 #if defined( VK_USE_PLATFORM_XCB_KHR )
10744   //=== VK_KHR_xcb_surface ===
10745 
10746 
10747     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10748     Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t * connection, xcb_visualid_t visual_id, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10750     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10751     VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10753 #endif /*VK_USE_PLATFORM_XCB_KHR*/
10754 
10755 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
10756   //=== VK_KHR_wayland_surface ===
10757 
10758 
10759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10760     Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display * display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10761 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10762     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10763     VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10765 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
10766 
10767 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10768   //=== VK_KHR_win32_surface ===
10769 
10770 
10771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10772     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10773 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
10774 
10775   //=== VK_KHR_video_queue ===
10776 
10777 
10778     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10779     VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile, VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10780 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10782     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10783     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10784     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10785 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10786 
10787 
10788     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10789     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, uint32_t * pVideoFormatPropertyCount, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10790 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10791     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10792     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10793     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = VideoFormatPropertiesKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
10794     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10795 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10796 
10797   //=== VK_NV_external_memory_capabilities ===
10798 
10799 
10800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10801     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType, VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10802 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10804     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10806 
10807   //=== VK_KHR_get_physical_device_properties2 ===
10808 
10809 
10810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10811     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10814     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10815     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10816     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10817 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10818 
10819 
10820     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10821     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10822 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10824     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10825     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10826     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10827 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10828 
10829 
10830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10831     void getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10833     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10834     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10835     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10836     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10838 
10839 
10840     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10841     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10844     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10845     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10846     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10847 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10848 
10849 
10850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10851     void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10853     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10854     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10855     template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = QueueFamilyProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, QueueFamilyProperties2>::value, int>::type = 0>
10856     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator> getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10857     template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10858     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10859     template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = StructureChainAllocator, typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
10860     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator> getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10861 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10862 
10863 
10864     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10865     void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10866 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10868     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10869     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10870     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10871 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10872 
10873 
10874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10875     void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10877     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10878     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10879     template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SparseImageFormatProperties2Allocator, typename std::enable_if<std::is_same<typename B1::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
10880     VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo, SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10881 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10882 
10883   //=== VK_KHR_external_memory_capabilities ===
10884 
10885 
10886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10887     void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10888 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10889     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10890     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10891 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10892 
10893   //=== VK_KHR_external_semaphore_capabilities ===
10894 
10895 
10896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10897     void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10900     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10902 
10903   //=== VK_EXT_direct_mode_display ===
10904 
10905 
10906 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10907     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10908     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10909 #else
10910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10911     void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10912 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10913 
10914 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
10915   //=== VK_EXT_acquire_xlib_display ===
10916 
10917 
10918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10919     VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10920 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10922     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10923 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10924 
10925 
10926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10927     VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy, RROutput rrOutput, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10928 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10929     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10930     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10931 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10932     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10933     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10934 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
10935 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10936 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
10937 
10938   //=== VK_EXT_display_surface_counter ===
10939 
10940 
10941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10942     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10943 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10944     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10945     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10946 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10947 
10948   //=== VK_KHR_external_fence_capabilities ===
10949 
10950 
10951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10952     void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10953 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10954     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10955     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10956 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10957 
10958   //=== VK_KHR_performance_query ===
10959 
10960 
10961     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10962     VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t * pCounterCount, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10964     template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10965     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10966     template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PerformanceCounterKHRAllocator, typename B2 = PerformanceCounterDescriptionKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value && std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value, int>::type = 0>
10967     VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, PerformanceCounterKHRAllocator & performanceCounterKHRAllocator, PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10968 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10969 
10970 
10971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10972     void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, uint32_t * pNumPasses, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10974     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10975     VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10976 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10977 
10978   //=== VK_KHR_get_surface_capabilities2 ===
10979 
10980 
10981     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10982     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10983 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10985     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10986     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10987     VULKAN_HPP_NODISCARD typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10989 
10990 
10991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10992     VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pSurfaceFormatCount, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10993 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10994     template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10995     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10996     template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = SurfaceFormat2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
10997     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10998     template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10999     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11000     template <typename StructureChain, typename StructureChainAllocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = StructureChainAllocator, typename std::enable_if<std::is_same<typename B1::value_type, StructureChain>::value, int>::type = 0>
11001     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<StructureChain, StructureChainAllocator>>::type getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11002 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11003 
11004   //=== VK_KHR_get_display_properties2 ===
11005 
11006 
11007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11008     VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11009 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11010     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11011     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11012     template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayProperties2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayProperties2KHR>::value, int>::type = 0>
11013     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11014 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11015 
11016 
11017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11018     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11019 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11020     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11021     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11022     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayPlaneProperties2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
11023     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11024 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11025 
11026 
11027     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11028     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11029 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11030     template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11031     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11032     template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = DisplayModeProperties2KHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
11033     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11034 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11035 
11036 
11037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11038     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo, VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11039 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11041     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11042 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11043 
11044   //=== VK_EXT_sample_locations ===
11045 
11046 
11047     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11048     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11049 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11050     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11051     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11052 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11053 
11054   //=== VK_EXT_calibrated_timestamps ===
11055 
11056 
11057     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11058     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11060     template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11061     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11062     template <typename TimeDomainEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = TimeDomainEXTAllocator, typename std::enable_if<std::is_same<typename B1::value_type, TimeDomainEXT>::value, int>::type = 0>
11063     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11064 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11065 
11066   //=== VK_KHR_fragment_shading_rate ===
11067 
11068 
11069     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11070     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11072     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11073     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11074     template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceFragmentShadingRateKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceFragmentShadingRateKHR>::value, int>::type = 0>
11075     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11076 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11077 
11078   //=== VK_EXT_tooling_info ===
11079 
11080 
11081     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11082     VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11084     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11085     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11086     template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceToolPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceToolProperties>::value, int>::type = 0>
11087     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator>>::type getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11088 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11089 
11090   //=== VK_NV_cooperative_matrix ===
11091 
11092 
11093     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11094     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11095 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11096     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11097     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11098     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = CooperativeMatrixPropertiesNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, CooperativeMatrixPropertiesNV>::value, int>::type = 0>
11099     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11100 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11101 
11102   //=== VK_NV_coverage_reduction_mode ===
11103 
11104 
11105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11106     VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount, VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11108     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11109     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11110     template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = FramebufferMixedSamplesCombinationNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, FramebufferMixedSamplesCombinationNV>::value, int>::type = 0>
11111     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11112 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11113 
11114 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11115   //=== VK_EXT_full_screen_exclusive ===
11116 
11117 
11118     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11119     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pPresentModeCount, VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11120 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11121     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11122     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11123     template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PresentModeKHRAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PresentModeKHR>::value, int>::type = 0>
11124     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR, PresentModeKHRAllocator>>::type getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11125 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11126 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11127 
11128   //=== VK_EXT_acquire_drm_display ===
11129 
11130 
11131 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11132     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11133     VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11134 #else
11135     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11136     typename ResultValueType<void>::type acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11137 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11138 
11139 
11140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11141     VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, VULKAN_HPP_NAMESPACE::DisplayKHR * display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11143     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11144     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11145 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11147     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11148 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11149 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11150 
11151 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11152   //=== VK_NV_acquire_winrt_display ===
11153 
11154 
11155 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11157     VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11158 #else
11159     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11160     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11161 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11162 
11163 
11164     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11165     VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11168     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11169 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11170     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11171     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11172 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11173 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11174 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11175 
11176 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
11177   //=== VK_EXT_directfb_surface ===
11178 
11179 
11180     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11181     Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11182 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11184     VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11185 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11186 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
11187 
11188 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
11189   //=== VK_QNX_screen_surface ===
11190 
11191 
11192     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11193     Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window * window, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11196     VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11197 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11198 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
11199 
11200   //=== VK_NV_optical_flow ===
11201 
11202 
11203     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11204     VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, uint32_t * pFormatCount, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11206     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11207     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11208     template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = OpticalFlowImageFormatPropertiesNVAllocator, typename std::enable_if<std::is_same<typename B1::value_type, OpticalFlowImageFormatPropertiesNV>::value, int>::type = 0>
11209     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator>>::type getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11211 
operator VkPhysicalDevice() const11212     operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
11213     {
11214       return m_physicalDevice;
11215     }
11216 
operator bool() const11217     explicit operator bool() const VULKAN_HPP_NOEXCEPT
11218     {
11219       return m_physicalDevice != VK_NULL_HANDLE;
11220     }
11221 
operator !() const11222     bool operator!() const VULKAN_HPP_NOEXCEPT
11223     {
11224       return m_physicalDevice == VK_NULL_HANDLE;
11225     }
11226 
11227   private:
11228     VkPhysicalDevice m_physicalDevice = {};
11229   };
11230 
11231   template <>
11232   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
11233   {
11234     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
11235   };
11236 
11237 
11238   template <>
11239   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
11240   {
11241     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
11242   };
11243 
11244 
11245   template <>
11246   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
11247   {
11248     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11249   };
11250 
11251 #ifndef VULKAN_HPP_NO_SMART_HANDLE
11252   class Instance;
11253   template <typename Dispatch>
11254   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
11255   {
11256   public:
11257     using deleter = ObjectDestroy<Instance, Dispatch>;
11258   };
11259   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
11260   template <typename Dispatch>
11261   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
11262   {
11263   public:
11264     using deleter = ObjectDestroy<Instance, Dispatch>;
11265   };
11266   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
11267   template <typename Dispatch>
11268   class UniqueHandleTraits<SurfaceKHR, Dispatch>
11269   {
11270   public:
11271     using deleter = ObjectDestroy<Instance, Dispatch>;
11272   };
11273   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
11274 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11275 
11276   class Instance
11277   {
11278   public:
11279     using CType = VkInstance;
11280     using NativeType = VkInstance;
11281 
11282     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
11283     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
11284 
11285   public:
11286     VULKAN_HPP_CONSTEXPR Instance() = default;
Instance(std::nullptr_t)11287     VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11288     {}
Instance(VkInstance instance)11289     Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT
11290       : m_instance( instance )
11291     {}
11292 
operator =(VkInstance instance)11293     Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
11294     {
11295       m_instance = instance;
11296       return *this;
11297     }
11298 
operator =(std::nullptr_t)11299     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11300     {
11301       m_instance = {};
11302       return *this;
11303     }
11304 
11305 #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
11306     auto operator<=>( Instance const & ) const = default;
11307 #else
operator ==(Instance const & rhs) const11308     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
11309     {
11310       return m_instance == rhs.m_instance;
11311     }
11312 
operator !=(Instance const & rhs) const11313     bool operator!=(Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
11314     {
11315       return m_instance != rhs.m_instance;
11316     }
11317 
operator <(Instance const & rhs) const11318     bool operator<(Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
11319     {
11320       return m_instance < rhs.m_instance;
11321     }
11322 #endif
11323 
11324   //=== VK_VERSION_1_0 ===
11325 
11326 
11327     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11328     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11331     void destroy( Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11332 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11333 
11334 
11335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11336     VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11337 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11338     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11339     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11340     template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDevice>::value, int>::type = 0>
11341     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice, PhysicalDeviceAllocator>>::type enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11342 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11343 
11344 
11345     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11346     PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11347 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11349     PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11350 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11351 
11352   //=== VK_VERSION_1_1 ===
11353 
11354 
11355     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11356     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11358     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11359     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11360     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0>
11361     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11362 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11363 
11364   //=== VK_KHR_surface ===
11365 
11366 
11367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11368     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11371     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11373 
11374 
11375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11376     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11378     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11379     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11381 
11382   //=== VK_KHR_display ===
11383 
11384 
11385     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11386     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11387 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11389     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11390 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11392     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11393 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11394 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11395 
11396 #if defined( VK_USE_PLATFORM_XLIB_KHR )
11397   //=== VK_KHR_xlib_surface ===
11398 
11399 
11400     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11401     VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11404     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11405 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11407     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11408 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11409 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11410 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
11411 
11412 #if defined( VK_USE_PLATFORM_XCB_KHR )
11413   //=== VK_KHR_xcb_surface ===
11414 
11415 
11416     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11417     VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11420     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11421 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11422     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11423     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11424 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11425 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11426 #endif /*VK_USE_PLATFORM_XCB_KHR*/
11427 
11428 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
11429   //=== VK_KHR_wayland_surface ===
11430 
11431 
11432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11433     VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11434 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11436     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11437 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11439     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11440 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11441 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11442 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
11443 
11444 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
11445   //=== VK_KHR_android_surface ===
11446 
11447 
11448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11449     VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11451     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11452     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11453 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11455     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11456 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11458 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
11459 
11460 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11461   //=== VK_KHR_win32_surface ===
11462 
11463 
11464     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11465     VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11466 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11467     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11468     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11469 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11471     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11472 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11473 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11474 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11475 
11476   //=== VK_EXT_debug_report ===
11477 
11478 
11479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11480     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11482     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11483     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11484 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11485     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11486     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11487 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11489 
11490 
11491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11492     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11493 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11494     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11495     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11497 
11498 
11499     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11500     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11501 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11503     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11504 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11505 
11506 
11507     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11508     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const char * pLayerPrefix, const char * pMessage, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11509 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11510     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11511     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11512 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11513 
11514 #if defined( VK_USE_PLATFORM_GGP )
11515   //=== VK_GGP_stream_descriptor_surface ===
11516 
11517 
11518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11519     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11522     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11523 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11525     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11526 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11527 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11528 #endif /*VK_USE_PLATFORM_GGP*/
11529 
11530 #if defined( VK_USE_PLATFORM_VI_NN )
11531   //=== VK_NN_vi_surface ===
11532 
11533 
11534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11535     VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11537     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11538     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11539 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11541     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11542 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11543 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11544 #endif /*VK_USE_PLATFORM_VI_NN*/
11545 
11546   //=== VK_KHR_device_group_creation ===
11547 
11548 
11549     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11550     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11551 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11552     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11553     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11554     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, PhysicalDeviceGroupProperties>::value, int>::type = 0>
11555     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11556 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11557 
11558 #if defined( VK_USE_PLATFORM_IOS_MVK )
11559   //=== VK_MVK_ios_surface ===
11560 
11561 
11562     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11563     VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11564 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11566     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11567 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11568     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11569     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11570 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11571 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11572 #endif /*VK_USE_PLATFORM_IOS_MVK*/
11573 
11574 #if defined( VK_USE_PLATFORM_MACOS_MVK )
11575   //=== VK_MVK_macos_surface ===
11576 
11577 
11578     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11579     VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11580 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11581     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11582     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11583 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11585     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11586 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11587 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11588 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
11589 
11590   //=== VK_EXT_debug_utils ===
11591 
11592 
11593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11594     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11595 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11597     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11598 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11599     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11600     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11601 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11602 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11603 
11604 
11605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11606     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, 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     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11610 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11611 
11612 
11613     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11614     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11615 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11617     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11618 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11619 
11620 
11621     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11622     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11624     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11625     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11626 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11627 
11628 #if defined( VK_USE_PLATFORM_FUCHSIA )
11629   //=== VK_FUCHSIA_imagepipe_surface ===
11630 
11631 
11632     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11633     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11634 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11635     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11636     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11637 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11638     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11639     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11640 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11641 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11642 #endif /*VK_USE_PLATFORM_FUCHSIA*/
11643 
11644 #if defined( VK_USE_PLATFORM_METAL_EXT )
11645   //=== VK_EXT_metal_surface ===
11646 
11647 
11648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11649     VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11651     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11652     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11653 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11654     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11655     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11656 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11657 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11658 #endif /*VK_USE_PLATFORM_METAL_EXT*/
11659 
11660   //=== VK_EXT_headless_surface ===
11661 
11662 
11663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11664     VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11665 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11667     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11668 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11670     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11671 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11672 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11673 
11674 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
11675   //=== VK_EXT_directfb_surface ===
11676 
11677 
11678     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11679     VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11680 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11681     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11682     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11683 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11684     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11685     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11686 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11687 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11688 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
11689 
11690 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
11691   //=== VK_QNX_screen_surface ===
11692 
11693 
11694     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11695     VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11696 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11698     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11699 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11701     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11702 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11703 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11704 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
11705 
operator VkInstance() const11706     operator VkInstance() const VULKAN_HPP_NOEXCEPT
11707     {
11708       return m_instance;
11709     }
11710 
operator bool() const11711     explicit operator bool() const VULKAN_HPP_NOEXCEPT
11712     {
11713       return m_instance != VK_NULL_HANDLE;
11714     }
11715 
operator !() const11716     bool operator!() const VULKAN_HPP_NOEXCEPT
11717     {
11718       return m_instance == VK_NULL_HANDLE;
11719     }
11720 
11721   private:
11722     VkInstance m_instance = {};
11723   };
11724 
11725   template <>
11726   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
11727   {
11728     using Type = VULKAN_HPP_NAMESPACE::Instance;
11729   };
11730 
11731 
11732   template <>
11733   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
11734   {
11735     using Type = VULKAN_HPP_NAMESPACE::Instance;
11736   };
11737 
11738 
11739   template <>
11740   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
11741   {
11742     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11743   };
11744 
11745   //=== VK_VERSION_1_0 ===
11746 
11747 #ifndef VULKAN_HPP_NO_SMART_HANDLE
11748   template <typename Dispatch>
11749   class UniqueHandleTraits<Instance, Dispatch>
11750   {
11751   public:
11752     using deleter = ObjectDestroy<NoParent, Dispatch>;
11753   };
11754   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
11755 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11756 
11757 
11758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11759     VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::Instance * pInstance, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
11760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11762     VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11763 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11764     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11765     VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11766 #  endif /* VULKAN_HPP_NO_SMART_HANDLE */
11767 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11768 
11769 
11770     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11771     VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
11772 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11773     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11774     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11775     template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = ExtensionPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, ExtensionProperties>::value, int>::type = 0>
11776     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties, ExtensionPropertiesAllocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, ExtensionPropertiesAllocator & extensionPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11777 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11778 
11779 
11780     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11781     VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
11782 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11783     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11784     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11785     template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename B1 = LayerPropertiesAllocator, typename std::enable_if<std::is_same<typename B1::value_type, LayerProperties>::value, int>::type = 0>
11786     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::LayerProperties, LayerPropertiesAllocator>>::type enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11787 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11788 
11789   //=== VK_VERSION_1_1 ===
11790 
11791 
11792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11793     VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
11794 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11795     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11796     VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
11797 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11798 
11799 }   // namespace VULKAN_HPP_NAMESPACE
11800 #endif
11801