chromium/third_party/vulkan-validation-layers/src/layers/vulkan/generated/stateless_validation_helper.cpp

// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See stateless_validation_helper_generator.py for modifications

/***************************************************************************
 *
 * Copyright (c) 2015-2024 The Khronos Group Inc.
 * Copyright (c) 2015-2024 Valve Corporation
 * Copyright (c) 2015-2024 LunarG, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ****************************************************************************/

// NOLINTBEGIN

#include "chassis.h"

#include "stateless/stateless_validation.h"
#include "generated/enum_flag_bits.h"
#include "generated/layer_chassis_dispatch.h"

bool StatelessValidation::ValidatePnextFeatureStructContents(const Location& loc, const VkBaseOutStructure* header,
                                                             const char* pnext_vuid, VkPhysicalDevice caller_physical_device,
                                                             bool is_const_param) const {}

bool StatelessValidation::ValidatePnextPropertyStructContents(const Location& loc, const VkBaseOutStructure* header,
                                                              const char* pnext_vuid, VkPhysicalDevice caller_physical_device,
                                                              bool is_const_param) const {}

// All structs that are not a Feature or Property struct
bool StatelessValidation::ValidatePnextStructContents(const Location& loc, const VkBaseOutStructure* header, const char* pnext_vuid,
                                                      VkPhysicalDevice caller_physical_device, bool is_const_param) const {}

bool StatelessValidation::PreCallValidateCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
                                                        const VkAllocationCallbacks* pAllocator, VkInstance* pInstance,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
                                                                  VkPhysicalDevice* pPhysicalDevices,
                                                                  const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
                                                                   VkPhysicalDeviceFeatures* pFeatures,
                                                                   const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
                                                                           VkFormatProperties* pFormatProperties,
                                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
                                                                                VkImageType type, VkImageTiling tiling,
                                                                                VkImageUsageFlags usage, VkImageCreateFlags flags,
                                                                                VkImageFormatProperties* pImageFormatProperties,
                                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
                                                                     VkPhysicalDeviceProperties* pProperties,
                                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
                                                                                uint32_t* pQueueFamilyPropertyCount,
                                                                                VkQueueFamilyProperties* pQueueFamilyProperties,
                                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
                                                                           VkPhysicalDeviceMemoryProperties* pMemoryProperties,
                                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
                                                      const VkAllocationCallbacks* pAllocator, VkDevice* pDevice,
                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
                                                        VkQueue* pQueue, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
                                                     VkFence fence, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateQueueWaitIdle(VkQueue queue, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDeviceWaitIdle(VkDevice device, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
                                                        const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator,
                                                    const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
                                                   VkMemoryMapFlags flags, void** ppData, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateUnmapMemory(VkDevice device, VkDeviceMemory memory, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
                                                                 const VkMappedMemoryRange* pMemoryRanges,
                                                                 const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
                                                                      const VkMappedMemoryRange* pMemoryRanges,
                                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
                                                                   VkDeviceSize* pCommittedMemoryInBytes,
                                                                   const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
                                                          VkDeviceSize memoryOffset, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
                                                         VkDeviceSize memoryOffset, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
                                                                     VkMemoryRequirements* pMemoryRequirements,
                                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetImageMemoryRequirements(VkDevice device, VkImage image,
                                                                    VkMemoryRequirements* pMemoryRequirements,
                                                                    const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetImageSparseMemoryRequirements(
    VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(
    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage,
    VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties,
    const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo,
                                                         VkFence fence, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
                                                     const VkAllocationCallbacks* pAllocator, VkFence* pFence,
                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator,
                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetFenceStatus(VkDevice device, VkFence fence, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
                                                       VkBool32 waitAll, uint64_t timeout, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
                                                         const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore semaphore,
                                                          const VkAllocationCallbacks* pAllocator,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
                                                     const VkAllocationCallbacks* pAllocator, VkEvent* pEvent,
                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator,
                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetEventStatus(VkDevice device, VkEvent event, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateSetEvent(VkDevice device, VkEvent event, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateResetEvent(VkDevice device, VkEvent event, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
                                                         const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
                                                          const VkAllocationCallbacks* pAllocator,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
                                                             uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride,
                                                             VkQueryResultFlags flags, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
                                                      const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer,
                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
                                                          const VkAllocationCallbacks* pAllocator, VkBufferView* pView,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyBufferView(VkDevice device, VkBufferView bufferView,
                                                           const VkAllocationCallbacks* pAllocator,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
                                                     const VkAllocationCallbacks* pAllocator, VkImage* pImage,
                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator,
                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetImageSubresourceLayout(VkDevice device, VkImage image,
                                                                   const VkImageSubresource* pSubresource,
                                                                   VkSubresourceLayout* pLayout,
                                                                   const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
                                                         const VkAllocationCallbacks* pAllocator, VkImageView* pView,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyImageView(VkDevice device, VkImageView imageView,
                                                          const VkAllocationCallbacks* pAllocator,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo,
                                                            const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
                                                             const VkAllocationCallbacks* pAllocator,
                                                             const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo,
                                                             const VkAllocationCallbacks* pAllocator,
                                                             VkPipelineCache* pPipelineCache, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
                                                              const VkAllocationCallbacks* pAllocator,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize,
                                                              void* pData, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
                                                             const VkPipelineCache* pSrcCaches,
                                                             const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
                                                                 uint32_t createInfoCount,
                                                                 const VkGraphicsPipelineCreateInfo* pCreateInfos,
                                                                 const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
                                                                 const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
                                                                uint32_t createInfoCount,
                                                                const VkComputePipelineCreateInfo* pCreateInfos,
                                                                const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyPipeline(VkDevice device, VkPipeline pipeline,
                                                         const VkAllocationCallbacks* pAllocator,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator,
                                                              VkPipelineLayout* pPipelineLayout,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
                                                               const VkAllocationCallbacks* pAllocator,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
                                                       const VkAllocationCallbacks* pAllocator, VkSampler* pSampler,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateDescriptorSetLayout(VkDevice device,
                                                                   const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
                                                                   const VkAllocationCallbacks* pAllocator,
                                                                   VkDescriptorSetLayout* pSetLayout,
                                                                   const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
                                                                    const VkAllocationCallbacks* pAllocator,
                                                                    const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator,
                                                              VkDescriptorPool* pDescriptorPool,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                                               const VkAllocationCallbacks* pAllocator,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                                             VkDescriptorPoolResetFlags flags, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo,
                                                                VkDescriptorSet* pDescriptorSets,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
                                                            uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
                                                              const VkWriteDescriptorSet* pDescriptorWrites,
                                                              uint32_t descriptorCopyCount,
                                                              const VkCopyDescriptorSet* pDescriptorCopies,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
                                                            const VkAllocationCallbacks* pAllocator,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
                                                          const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
                                                           const VkAllocationCallbacks* pAllocator,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
                                                                  VkExtent2D* pGranularity, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
                                                            const VkAllocationCallbacks* pAllocator,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo,
                                                                VkCommandBuffer* pCommandBuffers,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
                                                            const VkCommandBuffer* pCommandBuffers,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateBeginCommandBuffer(VkCommandBuffer commandBuffer,
                                                            const VkCommandBufferBeginInfo* pBeginInfo,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateEndCommandBuffer(VkCommandBuffer commandBuffer, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
                                                         VkPipeline pipeline, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
                                                        uint32_t viewportCount, const VkViewport* pViewports,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
                                                       const VkRect2D* pScissors, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
                                                         float depthBiasClamp, float depthBiasSlopeFactor,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4],
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
                                                           float maxDepthBounds, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                                                  uint32_t compareMask, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                                                uint32_t writeMask, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                                                uint32_t reference, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
                                                               VkPipelineLayout layout, uint32_t firstSet,
                                                               uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
                                                               uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                            VkIndexType indexType, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                                              uint32_t bindingCount, const VkBuffer* pBuffers,
                                                              const VkDeviceSize* pOffsets, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
                                                 uint32_t firstVertex, uint32_t firstInstance, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
                                                        uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                         uint32_t drawCount, uint32_t stride, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                                uint32_t drawCount, uint32_t stride,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
                                                     uint32_t groupCountZ, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                             const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
                                                       uint32_t regionCount, const VkBufferCopy* pRegions,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
                                                      VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
                                                      const VkImageCopy* pRegions, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
                                                      VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
                                                      const VkImageBlit* pRegions, VkFilter filter,
                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
                                                              VkImageLayout dstImageLayout, uint32_t regionCount,
                                                              const VkBufferImageCopy* pRegions,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
                                                              VkImageLayout srcImageLayout, VkBuffer dstBuffer,
                                                              uint32_t regionCount, const VkBufferImageCopy* pRegions,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                                         VkDeviceSize dataSize, const void* pData,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                                       VkDeviceSize size, uint32_t data, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
                                                            const VkClearColorValue* pColor, uint32_t rangeCount,
                                                            const VkImageSubresourceRange* pRanges,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
                                                                   VkImageLayout imageLayout,
                                                                   const VkClearDepthStencilValue* pDepthStencil,
                                                                   uint32_t rangeCount, const VkImageSubresourceRange* pRanges,
                                                                   const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
                                                             const VkClearAttachment* pAttachments, uint32_t rectCount,
                                                             const VkClearRect* pRects, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
                                                         VkImageLayout srcImageLayout, VkImage dstImage,
                                                         VkImageLayout dstImageLayout, uint32_t regionCount,
                                                         const VkImageResolve* pRegions, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask,
                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdWaitEvents(
    VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount,
    const VkImageMemoryBarrier* pImageMemoryBarriers, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdPipelineBarrier(
    VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
    VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount,
    const VkImageMemoryBarrier* pImageMemoryBarriers, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                                       VkQueryControlFlags flags, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                                           uint32_t firstQuery, uint32_t queryCount,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
                                                           VkQueryPool queryPool, uint32_t query,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                                                 uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer,
                                                                 VkDeviceSize dstOffset, VkDeviceSize stride,
                                                                 VkQueryResultFlags flags, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
                                                          VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
                                                          const void* pValues, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer,
                                                            const VkRenderPassBeginInfo* pRenderPassBegin,
                                                            VkSubpassContents contents, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
                                                            const VkCommandBuffer* pCommandBuffers,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
                                                           const VkBindBufferMemoryInfo* pBindInfos,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
                                                          const VkBindImageMemoryInfo* pBindInfos,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
                                                                          uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
                                                                          VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
                                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
                                                         uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
                                                         uint32_t groupCountZ, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateEnumeratePhysicalDeviceGroups(
    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
    const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
                                                                     VkMemoryRequirements2* pMemoryRequirements,
                                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
                                                                      VkMemoryRequirements2* pMemoryRequirements,
                                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetImageSparseMemoryRequirements2(
    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
                                                                    VkPhysicalDeviceFeatures2* pFeatures,
                                                                    const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
                                                                      VkPhysicalDeviceProperties2* pProperties,
                                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format,
                                                                            VkFormatProperties2* pFormatProperties,
                                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
                                                                                 uint32_t* pQueueFamilyPropertyCount,
                                                                                 VkQueueFamilyProperties2* pQueueFamilyProperties,
                                                                                 const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
                                                                            VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
                                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversion(VkDevice device,
                                                                      const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
                                                                      const VkAllocationCallbacks* pAllocator,
                                                                      VkSamplerYcbcrConversion* pYcbcrConversion,
                                                                      const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
                                                                       const VkAllocationCallbacks* pAllocator,
                                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateDescriptorUpdateTemplate(VkDevice device,
                                                                        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
                                                                        const VkAllocationCallbacks* pAllocator,
                                                                        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
                                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyDescriptorUpdateTemplate(VkDevice device,
                                                                         VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                                                         const VkAllocationCallbacks* pAllocator,
                                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet,
                                                                         VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                                                         const void* pData, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalBufferProperties(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalFenceProperties(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetDescriptorSetLayoutSupport(VkDevice device,
                                                                       const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
                                                                       VkDescriptorSetLayoutSupport* pSupport,
                                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                              VkBuffer countBuffer, VkDeviceSize countBufferOffset,
                                                              uint32_t maxDrawCount, uint32_t stride,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                     VkDeviceSize offset, VkBuffer countBuffer,
                                                                     VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                     uint32_t stride, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
                                                             const VkRenderPassBeginInfo* pRenderPassBegin,
                                                             const VkSubpassBeginInfo* pSubpassBeginInfo,
                                                             const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo,
                                                         const VkSubpassEndInfo* pSubpassEndInfo,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
                                                        uint32_t queryCount, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue,
                                                                  const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo,
                                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetDeviceMemoryOpaqueCaptureAddress(VkDevice device,
                                                                             const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo,
                                                                             const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
                                                                         VkPhysicalDeviceToolProperties* pToolProperties,
                                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
                                                               const VkAllocationCallbacks* pAllocator,
                                                               VkPrivateDataSlot* pPrivateDataSlot,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
                                                                const VkAllocationCallbacks* pAllocator,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
                                                        VkPrivateDataSlot privateDataSlot, uint64_t data,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
                                                        VkPrivateDataSlot privateDataSlot, uint64_t* pData,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
                                                      const VkDependencyInfo* pDependencyInfo, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
                                                        VkPipelineStageFlags2 stageMask, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
                                                        const VkDependencyInfo* pDependencyInfos,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo,
                                                             const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
                                                            VkQueryPool queryPool, uint32_t query,
                                                            const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
                                                      VkFence fence, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
                                                               const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
                                                               const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo,
                                                       const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdResolveImage2(VkCommandBuffer commandBuffer,
                                                          const VkResolveImageInfo2* pResolveImageInfo,
                                                          const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo,
                                                           const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdEndRendering(VkCommandBuffer commandBuffer, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode,
                                                        const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace,
                                                         const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
                                                                 VkPrimitiveTopology primitiveTopology,
                                                                 const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
                                                                 const VkViewport* pViewports, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
                                                                const VkRect2D* pScissors, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                                               uint32_t bindingCount, const VkBuffer* pBuffers,
                                                               const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
                                                               const VkDeviceSize* pStrides, const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable,
                                                               const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable,
                                                                const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp,
                                                              const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable,
                                                                     const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable,
                                                                 const ErrorObject& error_obj) const {}

bool StatelessValidation::PreCallValidateCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                                         VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
                                                         VkCompareOp compareOp, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
                                                                       VkBool32 rasterizerDiscardEnable,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
                                                                      VkBool32 primitiveRestartEnable,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceBufferMemoryRequirements(VkDevice device,
                                                                           const VkDeviceBufferMemoryRequirements* pInfo,
                                                                           VkMemoryRequirements2* pMemoryRequirements,
                                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirements(VkDevice device,
                                                                          const VkDeviceImageMemoryRequirements* pInfo,
                                                                          VkMemoryRequirements2* pMemoryRequirements,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirements(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
                                                           const VkAllocationCallbacks* pAllocator,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
                                                                            uint32_t queueFamilyIndex, VkSurfaceKHR surface,
                                                                            VkBool32* pSupported,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
                                                                                 VkSurfaceKHR surface,
                                                                                 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities,
                                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                                                                            uint32_t* pSurfaceFormatCount,
                                                                            VkSurfaceFormatKHR* pSurfaceFormats,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
                                                                                 VkSurfaceKHR surface, uint32_t* pPresentModeCount,
                                                                                 VkPresentModeKHR* pPresentModes,
                                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
                                                            const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                             const VkAllocationCallbacks* pAllocator,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                               uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
                                                             VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo,
                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
                                                                              VkDeviceGroupPresentModeFlagsKHR* pModes,
                                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
                                                                               VkSurfaceKHR surface, uint32_t* pRectCount,
                                                                               VkRect2D* pRects,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo,
                                                              uint32_t* pImageIndex, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                               uint32_t* pPropertyCount,
                                                                               VkDisplayPropertiesKHR* pProperties,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                                    uint32_t* pPropertyCount,
                                                                                    VkDisplayPlanePropertiesKHR* pProperties,
                                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
                                                                             uint32_t* pDisplayCount, VkDisplayKHR* pDisplays,
                                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                                     uint32_t* pPropertyCount,
                                                                     VkDisplayModePropertiesKHR* pProperties,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                              const VkDisplayModeCreateInfoKHR* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
                                                                        uint32_t planeIndex,
                                                                        VkDisplayPlaneCapabilitiesKHR* pCapabilities,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateDisplayPlaneSurfaceKHR(VkInstance instance,
                                                                      const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
                                                                      const VkAllocationCallbacks* pAllocator,
                                                                      VkSurfaceKHR* pSurface, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
                                                                   const VkSwapchainCreateInfoKHR* pCreateInfos,
                                                                   const VkAllocationCallbacks* pAllocator,
                                                                   VkSwapchainKHR* pSwapchains,
                                                                   const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_XLIB_KHRbool StatelessValidation::PreCallValidateCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                     uint32_t queueFamilyIndex, Display* dpy,
                                                                                     VisualID visualID,
                                                                                     const ErrorObject& error_obj) const {}#endif  // VK_USE_PLATFORM_XLIB_KHR#ifdef VK_USE_PLATFORM_XCB_KHRbool StatelessValidation::PreCallValidateCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                    uint32_t queueFamilyIndex,
                                                                                    xcb_connection_t* connection,
                                                                                    xcb_visualid_t visual_id,
                                                                                    const ErrorObject& error_obj) const {}#endif  // VK_USE_PLATFORM_XCB_KHR#ifdef VK_USE_PLATFORM_WAYLAND_KHRbool StatelessValidation::PreCallValidateCreateWaylandSurfaceKHR(VkInstance instance,
                                                                 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
                                                                 const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                        uint32_t queueFamilyIndex,
                                                                                        struct wl_display* display,
                                                                                        const ErrorObject& error_obj) const {}#endif  // VK_USE_PLATFORM_WAYLAND_KHR#ifdef VK_USE_PLATFORM_ANDROID_KHR#endif  // VK_USE_PLATFORM_ANDROID_KHR#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHRbool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
                                                                               const VkVideoProfileInfoKHR* pVideoProfile,
                                                                               VkVideoCapabilitiesKHR* pCapabilities,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoFormatPropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
    uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo,
                                                               const VkAllocationCallbacks* pAllocator,
                                                               VkVideoSessionKHR* pVideoSession,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
                                                                const VkAllocationCallbacks* pAllocator,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetVideoSessionMemoryRequirementsKHR(
    VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount,
    VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession,
                                                                   uint32_t bindSessionMemoryInfoCount,
                                                                   const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateVideoSessionParametersKHR(VkDevice device,
                                                                         const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
                                                                         const VkAllocationCallbacks* pAllocator,
                                                                         VkVideoSessionParametersKHR* pVideoSessionParameters,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateUpdateVideoSessionParametersKHR(VkDevice device,
                                                                         VkVideoSessionParametersKHR videoSessionParameters,
                                                                         const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyVideoSessionParametersKHR(VkDevice device,
                                                                          VkVideoSessionParametersKHR videoSessionParameters,
                                                                          const VkAllocationCallbacks* pAllocator,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
                                                                const VkVideoBeginCodingInfoKHR* pBeginInfo,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
                                                              const VkVideoEndCodingInfoKHR* pEndCodingInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer,
                                                                  const VkVideoCodingControlInfoKHR* pCodingControlInfo,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndRenderingKHR(VkCommandBuffer commandBuffer, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
                                                                       VkPhysicalDeviceFeatures2* pFeatures,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                         VkPhysicalDeviceProperties2* pProperties,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
                                                                               VkFormatProperties2* pFormatProperties,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(
    VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                               VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex,
                                                                             uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
                                                                             VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
                                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
                                                            uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
                                                            uint32_t groupCountZ, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
                                                            VkCommandPoolTrimFlags flags, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateEnumeratePhysicalDeviceGroupsKHR(
    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties, const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHRbool StatelessValidation::PreCallValidateGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd,
                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
                                                                  int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties, const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHRbool StatelessValidation::PreCallValidateImportSemaphoreFdKHR(VkDevice device,
                                                              const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
                                                                 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
                                                                 uint32_t set, uint32_t descriptorWriteCount,
                                                                 const VkWriteDescriptorSet* pDescriptorWrites,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
                                                                             VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                                                             VkPipelineLayout layout, uint32_t set,
                                                                             const void* pData,
                                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateDescriptorUpdateTemplateKHR(VkDevice device,
                                                                           const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
                                                                           const VkAllocationCallbacks* pAllocator,
                                                                           VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
                                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyDescriptorUpdateTemplateKHR(VkDevice device,
                                                                            VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                                                            const VkAllocationCallbacks* pAllocator,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet,
                                                                            VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                                                            const void* pData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
                                                                const VkRenderPassBeginInfo* pRenderPassBegin,
                                                                const VkSubpassBeginInfo* pSubpassBeginInfo,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
                                                            const VkSubpassBeginInfo* pSubpassBeginInfo,
                                                            const VkSubpassEndInfo* pSubpassEndInfo,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
                                                              const VkSubpassEndInfo* pSubpassEndInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties, const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHRbool StatelessValidation::PreCallValidateImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd,
                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters,
    VkPerformanceCounterDescriptionKHR* pCounterDescriptions, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
    VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateReleaseProfilingLockKHR(VkDevice device, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    VkSurfaceCapabilities2KHR* pSurfaceCapabilities, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
                                                                             const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
                                                                             uint32_t* pSurfaceFormatCount,
                                                                             VkSurfaceFormat2KHR* pSurfaceFormats,
                                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                                uint32_t* pPropertyCount,
                                                                                VkDisplayProperties2KHR* pProperties,
                                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                                     uint32_t* pPropertyCount,
                                                                                     VkDisplayPlaneProperties2KHR* pProperties,
                                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                                      uint32_t* pPropertyCount,
                                                                      VkDisplayModeProperties2KHR* pProperties,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
                                                                         const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
                                                                         VkDisplayPlaneCapabilities2KHR* pCapabilities,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device,
                                                                        const VkImageMemoryRequirementsInfo2* pInfo,
                                                                        VkMemoryRequirements2* pMemoryRequirements,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetBufferMemoryRequirements2KHR(VkDevice device,
                                                                         const VkBufferMemoryRequirementsInfo2* pInfo,
                                                                         VkMemoryRequirements2* pMemoryRequirements,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageSparseMemoryRequirements2KHR(
    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateSamplerYcbcrConversionKHR(VkDevice device,
                                                                         const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
                                                                         const VkAllocationCallbacks* pAllocator,
                                                                         VkSamplerYcbcrConversion* pYcbcrConversion,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
                                                                          const VkAllocationCallbacks* pAllocator,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
                                                              const VkBindBufferMemoryInfo* pBindInfos,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
                                                             const VkBindImageMemoryInfo* pBindInfos,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDescriptorSetLayoutSupportKHR(VkDevice device,
                                                                          const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
                                                                          VkDescriptorSetLayoutSupport* pSupport,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                 VkDeviceSize offset, VkBuffer countBuffer,
                                                                 VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                 uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                        VkDeviceSize offset, VkBuffer countBuffer,
                                                                        VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                        uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceFragmentShadingRatesKHR(
    VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount,
    VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,
                                                                      const VkExtent2D* pFragmentSize,
                                                                      const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRenderingAttachmentLocationsKHR(
    VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRenderingInputAttachmentIndicesKHR(
    VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId,
                                                           uint64_t timeout, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device,
                                                                                const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo,
                                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator,
                                                                    VkDeferredOperationKHR* pDeferredOperation,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation,
                                                                     const VkAllocationCallbacks* pAllocator,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo,
                                                                            uint32_t* pExecutableCount,
                                                                            VkPipelineExecutablePropertiesKHR* pProperties,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineExecutableStatisticsKHR(VkDevice device,
                                                                            const VkPipelineExecutableInfoKHR* pExecutableInfo,
                                                                            uint32_t* pStatisticCount,
                                                                            VkPipelineExecutableStatisticKHR* pStatistics,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount,
    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData,
                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo,
                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo,
    VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetEncodedVideoSessionParametersKHR(
    VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo,
    VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
                                                         const VkDependencyInfo* pDependencyInfo,
                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
                                                           VkPipelineStageFlags2 stageMask, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
                                                           const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
                                                                const VkDependencyInfo* pDependencyInfo,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
                                                               VkQueryPool queryPool, uint32_t query,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
                                                         VkFence fence, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
                                                                  VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
                                                                   VkCheckpointData2NV* pCheckpointData,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
                                                                  const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
                                                                  const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
                                                             const VkResolveImageInfo2* pResolveImageInfo,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer,
                                                                  VkDeviceAddress indirectDeviceAddress,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceBufferMemoryRequirementsKHR(VkDevice device,
                                                                              const VkDeviceBufferMemoryRequirements* pInfo,
                                                                              VkMemoryRequirements2* pMemoryRequirements,
                                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceImageMemoryRequirementsKHR(VkDevice device,
                                                                             const VkDeviceImageMemoryRequirements* pInfo,
                                                                             VkMemoryRequirements2* pMemoryRequirements,
                                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceImageSparseMemoryRequirementsKHR(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                                VkDeviceSize size, VkIndexType indexType,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetRenderingAreaGranularityKHR(VkDevice device,
                                                                        const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
                                                                        VkExtent2D* pGranularity,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceImageSubresourceLayoutKHR(VkDevice device,
                                                                            const VkDeviceImageSubresourceInfoKHR* pInfo,
                                                                            VkSubresourceLayout2KHR* pLayout,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
                                                                       const VkImageSubresource2KHR* pSubresource,
                                                                       VkSubresourceLayout2KHR* pLayout,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreatePipelineBinariesKHR(VkDevice device,
                                                                   const VkPipelineBinaryCreateInfoKHR* pCreateInfo,
                                                                   const VkAllocationCallbacks* pAllocator,
                                                                   VkPipelineBinaryHandlesInfoKHR* pBinaries,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary,
                                                                  const VkAllocationCallbacks* pAllocator,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo,
                                                           VkPipelineBinaryKeyKHR* pPipelineKey,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo,
                                                                  VkPipelineBinaryKeyKHR* pPipelineBinaryKey,
                                                                  size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateReleaseCapturedPipelineDataKHR(VkDevice device,
                                                                        const VkReleaseCapturedPipelineDataInfoKHR* pInfo,
                                                                        const VkAllocationCallbacks* pAllocator,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesKHR(
    VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
                                                              uint16_t lineStipplePattern, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice,
                                                                                      uint32_t* pTimeDomainCount,
                                                                                      VkTimeDomainKHR* pTimeDomains,
                                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount,
                                                                    const VkCalibratedTimestampInfoKHR* pTimestampInfos,
                                                                    uint64_t* pTimestamps, uint64_t* pMaxDeviation,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer,
                                                                   const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPushConstants2KHR(VkCommandBuffer commandBuffer,
                                                              const VkPushConstantsInfoKHR* pPushConstantsInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
                                                                  const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPushDescriptorSetWithTemplate2KHR(
    VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDescriptorBufferOffsets2EXT(
    VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindDescriptorBufferEmbeddedSamplers2EXT(
    VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance,
                                                                      const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
                                                                      const VkAllocationCallbacks* pAllocator,
                                                                      VkDebugReportCallbackEXT* pCallback,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
                                                                       const VkAllocationCallbacks* pAllocator,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
                                                               VkDebugReportObjectTypeEXT objectType, uint64_t object,
                                                               size_t location, int32_t messageCode, const char* pLayerPrefix,
                                                               const char* pMessage, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDebugMarkerSetObjectNameEXT(VkDevice device,
                                                                     const VkDebugMarkerObjectNameInfoEXT* pNameInfo,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
                                                                const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,
                                                                 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                                                            uint32_t bindingCount, const VkBuffer* pBuffers,
                                                                            const VkDeviceSize* pOffsets,
                                                                            const VkDeviceSize* pSizes,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
                                                                      uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
                                                                      const VkDeviceSize* pCounterBufferOffsets,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
                                                                    uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
                                                                    const VkDeviceSize* pCounterBufferOffsets,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                                                 uint32_t query, VkQueryControlFlags flags, uint32_t index,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                                               uint32_t index, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
                                                                     uint32_t firstInstance, VkBuffer counterBuffer,
                                                                     VkDeviceSize counterBufferOffset, uint32_t counterOffset,
                                                                     uint32_t vertexStride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo,
                                                             const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
                                                            const VkAllocationCallbacks* pAllocator,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
                                                              const VkAllocationCallbacks* pAllocator,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageViewAddressNVX(VkDevice device, VkImageView imageView,
                                                                VkImageViewAddressPropertiesNVX* pProperties,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                 VkDeviceSize offset, VkBuffer countBuffer,
                                                                 VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                 uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                        VkDeviceSize offset, VkBuffer countBuffer,
                                                                        VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                        uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage,
                                                          VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo,
                                                          const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_GGP#endif  // VK_USE_PLATFORM_GGPbool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(
    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
    VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHR#ifdef VK_USE_PLATFORM_VI_NN#endif  // VK_USE_PLATFORM_VI_NNbool StatelessValidation::PreCallValidateCmdBeginConditionalRenderingEXT(
    VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
                                                                  uint32_t viewportCount,
                                                                  const VkViewportWScalingNV* pViewportWScalings,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                           const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT#endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXTbool StatelessValidation::PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
                                                                                  VkSurfaceKHR surface,
                                                                                  VkSurfaceCapabilities2EXT* pSurfaceCapabilities,
                                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
                                                                const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo,
                                                                const VkAllocationCallbacks* pAllocator, VkFence* pFence,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display,
                                                                 const VkDisplayEventInfoEXT* pDisplayEventInfo,
                                                                 const VkAllocationCallbacks* pAllocator, VkFence* pFence,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
                                                                VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
                                                                       VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
                                                                         uint32_t* pPresentationTimingCount,
                                                                         VkPastPresentationTimingGOOGLE* pPresentationTimings,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
                                                                   uint32_t discardRectangleCount,
                                                                   const VkRect2D* pDiscardRectangles,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer,
                                                                         VkBool32 discardRectangleEnable,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer,
                                                                       VkDiscardRectangleModeEXT discardRectangleMode,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount,
                                                           const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata,
                                                           const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_IOS_MVK#endif  // VK_USE_PLATFORM_IOS_MVK#ifdef VK_USE_PLATFORM_MACOS_MVK#endif  // VK_USE_PLATFORM_MACOS_MVKbool StatelessValidation::PreCallValidateSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueueEndDebugUtilsLabelEXT(VkQueue queue, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
                                                                    const VkDebugUtilsLabelEXT* pLabelInfo,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
                                                                     const VkDebugUtilsLabelEXT* pLabelInfo,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateDebugUtilsMessengerEXT(VkInstance instance,
                                                                      const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
                                                                      const VkAllocationCallbacks* pAllocator,
                                                                      VkDebugUtilsMessengerEXT* pMessenger,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
                                                                       const VkAllocationCallbacks* pAllocator,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSubmitDebugUtilsMessageEXT(VkInstance instance,
                                                                    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
                                                                    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
                                                                    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
                                                                    const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_ANDROID_KHR#endif  // VK_USE_PLATFORM_ANDROID_KHR#ifdef VK_ENABLE_BETA_EXTENSIONSbool StatelessValidation::PreCallValidateCreateExecutionGraphPipelinesAMDX(
    VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
    const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetExecutionGraphPipelineScratchSizeAMDX(
    VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetExecutionGraphPipelineNodeIndexAMDX(
    VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
                                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
                                                              const VkDispatchGraphCountInfoAMDX* pCountInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
                                                                      const VkDispatchGraphCountInfoAMDX* pCountInfo,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
                                                                           VkDeviceAddress countInfo,
                                                                           const ErrorObject& error_obj) const {}#endif  // VK_ENABLE_BETA_EXTENSIONSbool StatelessValidation::PreCallValidateCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
                                                                  const VkSampleLocationsInfoEXT* pSampleLocationsInfo,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(
    VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image,
                                                                                VkImageDrmFormatModifierPropertiesEXT* pProperties,
                                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateValidationCacheEXT(VkDevice device,
                                                                  const VkValidationCacheCreateInfoEXT* pCreateInfo,
                                                                  const VkAllocationCallbacks* pAllocator,
                                                                  VkValidationCacheEXT* pValidationCache,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
                                                                   const VkAllocationCallbacks* pAllocator,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache,
                                                                  uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache,
                                                                   size_t* pDataSize, void* pData,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
                                                                   VkImageLayout imageLayout, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
                                                                            uint32_t viewportCount,
                                                                            const VkShadingRatePaletteNV* pShadingRatePalettes,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
                                                                   VkCoarseSampleOrderTypeNV sampleOrderType,
                                                                   uint32_t customSampleOrderCount,
                                                                   const VkCoarseSampleOrderCustomNV* pCustomSampleOrders,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateAccelerationStructureNV(VkDevice device,
                                                                       const VkAccelerationStructureCreateInfoNV* pCreateInfo,
                                                                       const VkAllocationCallbacks* pAllocator,
                                                                       VkAccelerationStructureNV* pAccelerationStructure,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyAccelerationStructureNV(VkDevice device,
                                                                        VkAccelerationStructureNV accelerationStructure,
                                                                        const VkAllocationCallbacks* pAllocator,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetAccelerationStructureMemoryRequirementsNV(
    VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBindAccelerationStructureMemoryNV(
    VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBuildAccelerationStructureNV(
    VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset,
    VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
                                                                        VkAccelerationStructureNV dst,
                                                                        VkAccelerationStructureNV src,
                                                                        VkCopyAccelerationStructureModeKHR mode,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdTraceRaysNV(
    VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset,
    VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
    VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride,
    VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
    uint32_t width, uint32_t height, uint32_t depth, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache,
                                                                     uint32_t createInfoCount,
                                                                     const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
                                                                     const VkAllocationCallbacks* pAllocator,
                                                                     VkPipeline* pPipelines, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
                                                                            uint32_t firstGroup, uint32_t groupCount,
                                                                            size_t dataSize, void* pData,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline,
                                                                           uint32_t firstGroup, uint32_t groupCount,
                                                                           size_t dataSize, void* pData,
                                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetAccelerationStructureHandleNV(VkDevice device,
                                                                          VkAccelerationStructureNV accelerationStructure,
                                                                          size_t dataSize, void* pData,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(
    VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures,
    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetMemoryHostPointerPropertiesEXT(
    VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
                                                                 VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer,
                                                                 VkDeviceSize dstOffset, uint32_t marker,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
                                                                                      uint32_t* pTimeDomainCount,
                                                                                      VkTimeDomainKHR* pTimeDomains,
                                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount,
                                                                    const VkCalibratedTimestampInfoKHR* pTimestampInfos,
                                                                    uint64_t* pTimestamps, uint64_t* pMaxDeviation,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                    VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                         VkDeviceSize offset, VkBuffer countBuffer,
                                                                         VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                         uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer,
                                                                        uint32_t firstExclusiveScissor,
                                                                        uint32_t exclusiveScissorCount,
                                                                        const VkBool32* pExclusiveScissorEnables,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
                                                                  uint32_t exclusiveScissorCount,
                                                                  const VkRect2D* pExclusiveScissors,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount,
                                                                  VkCheckpointDataNV* pCheckpointData,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateInitializePerformanceApiINTEL(VkDevice device,
                                                                       const VkInitializePerformanceApiInfoINTEL* pInitializeInfo,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateUninitializePerformanceApiINTEL(VkDevice device, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,
                                                                      const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,
                                                                            const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,
                                                                        const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateAcquirePerformanceConfigurationINTEL(
    VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
    VkPerformanceConfigurationINTEL* pConfiguration, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateReleasePerformanceConfigurationINTEL(VkDevice device,
                                                                              VkPerformanceConfigurationINTEL configuration,
                                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueueSetPerformanceConfigurationINTEL(VkQueue queue,
                                                                               VkPerformanceConfigurationINTEL configuration,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter,
                                                                      VkPerformanceValueINTEL* pValue,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable,
                                                            const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_FUCHSIA#endif  // VK_USE_PLATFORM_FUCHSIA#ifdef VK_USE_PLATFORM_METAL_EXT#endif  // VK_USE_PLATFORM_METAL_EXTbool StatelessValidation::PreCallValidateGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
                                                                            VkPhysicalDeviceToolProperties* pToolProperties,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(
    VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
    VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations,
    const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHRbool StatelessValidation::PreCallValidateCreateHeadlessSurfaceEXT(VkInstance instance,
                                                                  const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
                                                                  const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
                                                              uint16_t lineStipplePattern, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
                                                           uint32_t queryCount, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
                                                                    VkPrimitiveTopology primitiveTopology,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
                                                                    const VkViewport* pViewports,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
                                                                   const VkRect2D* pScissors, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                                                  uint32_t bindingCount, const VkBuffer* pBuffers,
                                                                  const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
                                                                  const VkDeviceSize* pStrides,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
                                                                        VkBool32 depthBoundsTestEnable,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                                            VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
                                                            VkCompareOp compareOp, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyMemoryToImageEXT(VkDevice device,
                                                              const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyImageToMemoryEXT(VkDevice device,
                                                              const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyImageToImageEXT(VkDevice device,
                                                             const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount,
                                                                  const VkHostImageLayoutTransitionInfoEXT* pTransitions,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
                                                                       const VkImageSubresource2KHR* pSubresource,
                                                                       VkSubresourceLayout2KHR* pLayout,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateReleaseSwapchainImagesEXT(VkDevice device,
                                                                   const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetGeneratedCommandsMemoryRequirementsNV(
    VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer,
                                                                          const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
                                                                       const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
                                                                      VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline,
                                                                      uint32_t groupIndex, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateIndirectCommandsLayoutNV(VkDevice device,
                                                                        const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
                                                                        const VkAllocationCallbacks* pAllocator,
                                                                        VkIndirectCommandsLayoutNV* pIndirectCommandsLayout,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyIndirectCommandsLayoutNV(VkDevice device,
                                                                         VkIndirectCommandsLayoutNV indirectCommandsLayout,
                                                                         const VkAllocationCallbacks* pAllocator,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer,
                                                             const VkDepthBiasInfoEXT* pDepthBiasInfo,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId,
                                                          VkDisplayKHR* display, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
                                                                  const VkAllocationCallbacks* pAllocator,
                                                                  VkPrivateDataSlot* pPrivateDataSlot,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
                                                                   const VkAllocationCallbacks* pAllocator,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
                                                           VkPrivateDataSlot privateDataSlot, uint64_t data,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
                                                           VkPrivateDataSlot privateDataSlot, uint64_t* pData,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo,
                                                            const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize,
                                                              void* pCacheData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module,
                                                             const VkAllocationCallbacks* pAllocator,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function,
                                                               const VkAllocationCallbacks* pAllocator,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo,
                                                               const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_METAL_EXT#endif  // VK_USE_PLATFORM_METAL_EXTbool StatelessValidation::PreCallValidateGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout,
                                                                       VkDeviceSize* pLayoutSizeInBytes,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout,
                                                                                uint32_t binding, VkDeviceSize* pOffset,
                                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo,
                                                          size_t dataSize, void* pDescriptor, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount,
                                                                     const VkDescriptorBufferBindingInfoEXT* pBindingInfos,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDescriptorBufferOffsetsEXT(
    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet,
    uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer,
                                                                                    VkPipelineBindPoint pipelineBindPoint,
                                                                                    VkPipelineLayout layout, uint32_t set,
                                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device,
                                                                                 const VkBufferCaptureDescriptorDataInfoEXT* pInfo,
                                                                                 void* pData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device,
                                                                                const VkImageCaptureDescriptorDataInfoEXT* pInfo,
                                                                                void* pData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetImageViewOpaqueCaptureDescriptorDataEXT(
    VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetSamplerOpaqueCaptureDescriptorDataEXT(
    VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
    VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
                                                                         VkFragmentShadingRateNV shadingRate,
                                                                         const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts,
                                                               VkDeviceFaultInfoEXT* pFaultInfo,
                                                               const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_WIN32_KHR#endif  // VK_USE_PLATFORM_WIN32_KHR#ifdef VK_USE_PLATFORM_DIRECTFB_EXT#endif  // VK_USE_PLATFORM_DIRECTFB_EXTbool StatelessValidation::PreCallValidateCmdSetVertexInputEXT(
    VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
    const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount,
    const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions, const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_FUCHSIA#endif  // VK_USE_PLATFORM_FUCHSIAbool StatelessValidation::PreCallValidateGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass,
                                                                                       VkExtent2D* pMaxWorkgroupSize,
                                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView,
                                                                     VkImageLayout imageLayout,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetMemoryRemoteAddressNV(VkDevice device,
                                                                  const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
                                                                  VkRemoteAddressNV* pAddress, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo,
                                                                  VkBaseOutStructure* pPipelineProperties,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
                                                                          VkBool32 rasterizerDiscardEnable,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
                                                                         VkBool32 primitiveRestartEnable,
                                                                         const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_SCREEN_QNX#endif  // VK_USE_PLATFORM_SCREEN_QNXbool StatelessValidation::PreCallValidateCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
                                                                   const VkBool32* pColorWriteEnables,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
                                                         const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount,
                                                         uint32_t firstInstance, uint32_t stride,
                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
                                                                const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount,
                                                                uint32_t firstInstance, uint32_t stride,
                                                                const int32_t* pVertexOffset, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap,
                                                            const VkAllocationCallbacks* pAllocator,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount,
                                                              const VkMicromapBuildInfoEXT* pInfos,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
                                                           uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
                                                         const VkCopyMicromapInfoEXT* pInfo, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
                                                                 const VkCopyMicromapToMemoryInfoEXT* pInfo,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
                                                                 const VkCopyMemoryToMicromapInfoEXT* pInfo,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount,
                                                                     const VkMicromapEXT* pMicromaps, VkQueryType queryType,
                                                                     size_t dataSize, void* pData, size_t stride,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer,
                                                                    const VkCopyMicromapToMemoryInfoEXT* pInfo,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer,
                                                                    const VkCopyMemoryToMicromapInfoEXT* pInfo,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount,
                                                                        const VkMicromapEXT* pMicromaps, VkQueryType queryType,
                                                                        VkQueryPool queryPool, uint32_t firstQuery,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceMicromapCompatibilityEXT(VkDevice device,
                                                                           const VkMicromapVersionInfoEXT* pVersionInfo,
                                                                           VkAccelerationStructureCompatibilityKHR* pCompatibility,
                                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
                                                                  const VkMicromapBuildInfoEXT* pBuildInfo,
                                                                  VkMicromapBuildSizesInfoEXT* pSizeInfo,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX,
                                                              uint32_t groupCountY, uint32_t groupCountZ,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                      VkDeviceSize offset, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDescriptorSetLayoutHostMappingInfoVALVE(
    VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
    VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet,
                                                                          void** ppData, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress,
                                                                 uint32_t copyCount, uint32_t stride,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyMemoryToImageIndirectNV(
    VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage,
    VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount,
                                                               const VkDecompressMemoryRegionNV* pDecompressMemoryRegions,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer,
                                                                            VkDeviceAddress indirectCommandsAddress,
                                                                            VkDeviceAddress indirectCommandsCountAddress,
                                                                            uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineIndirectMemoryRequirementsNV(VkDevice device,
                                                                                 const VkComputePipelineCreateInfo* pCreateInfo,
                                                                                 VkMemoryRequirements2* pMemoryRequirements,
                                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer,
                                                                           VkPipelineBindPoint pipelineBindPoint,
                                                                           VkPipeline pipeline,
                                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPipelineIndirectDeviceAddressNV(VkDevice device,
                                                                            const VkPipelineIndirectDeviceAddressInfoNV* pInfo,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode,
                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer,
                                                                       VkSampleCountFlagBits rasterizationSamples,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples,
                                                             const VkSampleMask* pSampleMask, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer,
                                                                        VkBool32 alphaToCoverageEnable,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
                                                                   uint32_t attachmentCount, const VkBool32* pColorBlendEnables,
                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
                                                                     uint32_t attachmentCount,
                                                                     const VkColorBlendEquationEXT* pColorBlendEquations,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
                                                                 uint32_t attachmentCount,
                                                                 const VkColorComponentFlags* pColorWriteMasks,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer,
                                                                           VkTessellationDomainOrigin domainOrigin,
                                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetConservativeRasterizationModeEXT(
    VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer,
                                                                                   float extraPrimitiveOverestimationSize,
                                                                                   const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable,
                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer,
                                                                        VkBool32 sampleLocationsEnable,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
                                                                     uint32_t attachmentCount,
                                                                     const VkColorBlendAdvancedEXT* pColorBlendAdvanced,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer,
                                                                      VkProvokingVertexModeEXT provokingVertexMode,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer,
                                                                        VkLineRasterizationModeEXT lineRasterizationMode,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer,
                                                                            VkBool32 negativeOneToOne,
                                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer,
                                                                        VkBool32 viewportWScalingEnable,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
                                                                 uint32_t viewportCount,
                                                                 const VkViewportSwizzleNV* pViewportSwizzles,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer,
                                                                       VkBool32 coverageToColorEnable,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer,
                                                                         uint32_t coverageToColorLocation,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer,
                                                                        VkCoverageModulationModeNV coverageModulationMode,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer,
                                                                               VkBool32 coverageModulationTableEnable,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer,
                                                                         uint32_t coverageModulationTableCount,
                                                                         const float* pCoverageModulationTable,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer,
                                                                        VkBool32 shadingRateImageEnable,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer,
                                                                                  VkBool32 representativeFragmentTestEnable,
                                                                                  const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer,
                                                                       VkCoverageReductionModeNV coverageReductionMode,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule,
                                                                      VkShaderModuleIdentifierEXT* pIdentifier,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetShaderModuleCreateInfoIdentifierEXT(VkDevice device,
                                                                                const VkShaderModuleCreateInfo* pCreateInfo,
                                                                                VkShaderModuleIdentifierEXT* pIdentifier,
                                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetPhysicalDeviceOpticalFlowImageFormatsNV(
    VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount,
    VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateOpticalFlowSessionNV(VkDevice device,
                                                                    const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
                                                                    const VkAllocationCallbacks* pAllocator,
                                                                    VkOpticalFlowSessionNV* pSession,
                                                                    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session,
                                                                     const VkAllocationCallbacks* pAllocator,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session,
                                                                       VkOpticalFlowSessionBindingPointNV bindingPoint,
                                                                       VkImageView view, VkImageLayout layout,
                                                                       const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session,
                                                                 const VkOpticalFlowExecuteInfoNV* pExecuteInfo,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateShadersEXT(VkDevice device, uint32_t createInfoCount,
                                                          const VkShaderCreateInfoEXT* pCreateInfos,
                                                          const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyShaderEXT(VkDevice device, VkShaderEXT shader,
                                                          const VkAllocationCallbacks* pAllocator,
                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount,
                                                           const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders,
                                                           const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer,
                                                                          uint32_t* pPropertiesCount,
                                                                          VkTilePropertiesQCOM* pProperties,
                                                                          const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDynamicRenderingTilePropertiesQCOM(VkDevice device,
                                                                               const VkRenderingInfo* pRenderingInfo,
                                                                               VkTilePropertiesQCOM* pProperties,
                                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
                                                               const VkLatencySleepModeInfoNV* pSleepModeInfo,
                                                               const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain,
                                                        const VkLatencySleepInfoNV* pSleepInfo,
                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain,
                                                            const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo,
                                                            const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain,
                                                             VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo,
                                                                const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer,
                                                                               VkImageAspectFlags aspectMask,
                                                                               const ErrorObject& error_obj) const {}#ifdef VK_USE_PLATFORM_SCREEN_QNX#endif  // VK_USE_PLATFORM_SCREEN_QNXbool StatelessValidation::PreCallValidateCreateAccelerationStructureKHR(VkDevice device,
                                                                        const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
                                                                        const VkAllocationCallbacks* pAllocator,
                                                                        VkAccelerationStructureKHR* pAccelerationStructure,
                                                                        const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateDestroyAccelerationStructureKHR(VkDevice device,
                                                                         VkAccelerationStructureKHR accelerationStructure,
                                                                         const VkAllocationCallbacks* pAllocator,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBuildAccelerationStructuresKHR(
    VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdBuildAccelerationStructuresIndirectKHR(
    VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
    const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateBuildAccelerationStructuresKHR(
    VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
    const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation,
                                                                      const VkCopyAccelerationStructureInfoKHR* pInfo,
                                                                      const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyAccelerationStructureToMemoryKHR(
    VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCopyMemoryToAccelerationStructureKHR(
    VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
    const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateWriteAccelerationStructuresPropertiesKHR(
    VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures,
    VkQueryType queryType, size_t dataSize, void* pData, size_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,
                                                                         const VkCopyAccelerationStructureInfoKHR* pInfo,
                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyAccelerationStructureToMemoryKHR(
    VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdCopyMemoryToAccelerationStructureKHR(
    VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetAccelerationStructureDeviceAddressKHR(
    VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdWriteAccelerationStructuresPropertiesKHR(
    VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures,
    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetDeviceAccelerationStructureCompatibilityKHR(
    VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
    VkAccelerationStructureCompatibilityKHR* pCompatibility, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetAccelerationStructureBuildSizesKHR(
    VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
    const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdTraceRaysKHR(VkCommandBuffer commandBuffer,
                                                         const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
                                                         const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
                                                         const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
                                                         const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
                                                         uint32_t width, uint32_t height, uint32_t depth,
                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation,
                                                                      VkPipelineCache pipelineCache, uint32_t createInfoCount,
                                                                      const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
                                                                      const VkAllocationCallbacks* pAllocator,
                                                                      VkPipeline* pPipelines, const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
                                                                                         uint32_t firstGroup, uint32_t groupCount,
                                                                                         size_t dataSize, void* pData,
                                                                                         const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
                                                                 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
                                                                 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
                                                                 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
                                                                 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
                                                                 VkDeviceAddress indirectDeviceAddress,
                                                                 const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group,
                                                                              VkShaderGroupShaderKHR groupShader,
                                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
                                                                              uint32_t pipelineStackSize,
                                                                              const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX,
                                                             uint32_t groupCountY, uint32_t groupCountZ,
                                                             const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                     VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
                                                                     const ErrorObject& error_obj) const {}bool StatelessValidation::PreCallValidateCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                                          VkDeviceSize offset, VkBuffer countBuffer,
                                                                          VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                                          uint32_t stride, const ErrorObject& error_obj) const {}bool StatelessValidation::ValidatePipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo& info,
                                                                  const Location& loc) const {}bool StatelessValidation::ValidatePipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo& info,
                                                                      const Location& loc) const {}bool StatelessValidation::ValidatePipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo& info,
                                                                     const Location& loc) const {}bool StatelessValidation::ValidatePipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo& info,
                                                                     const Location& loc) const {}bool StatelessValidation::ValidatePipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo& info,
                                                                    const Location& loc) const {}bool StatelessValidation::ValidatePipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo& info,
                                                                      const Location& loc) const {}bool StatelessValidation::ValidatePipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo& info,
                                                                       const Location& loc) const {}bool StatelessValidation::ValidatePipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo& info,
                                                                       const Location& loc) const {}bool StatelessValidation::ValidatePipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo& info,
                                                                const Location& loc) const {}bool StatelessValidation::ValidateDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT& info, const Location& loc) const {}