chromium/out/Default/gen/third_party/dawn/include/dawn/webgpu_cpp.h

// Copyright 2017 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


#ifdef __EMSCRIPTEN__
#error "Do not include this header. Emscripten already provides headers needed for WebGPU."
#endif

#ifndef WEBGPU_CPP_H_
#define WEBGPU_CPP_H_

#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <functional>
#include <string_view>
#include <type_traits>
#include <utility>

#include "webgpu/webgpu.h"
#include "webgpu/webgpu_cpp_chained_struct.h"
#include "webgpu/webgpu_enum_class_bitmasks.h"  // IWYU pragma: export

namespace wgpu {

namespace detail {
constexpr size_t ConstexprMax(size_t a, size_t b) { … }

template <typename T>
static T& AsNonConstReference(const T& value) { … }
}  // namespace detail

static constexpr uint32_t kArrayLayerCountUndefined = …;
static constexpr uint32_t kCopyStrideUndefined = …;
static constexpr uint32_t kDepthSliceUndefined = …;
static constexpr uint32_t kLimitU32Undefined = …;
static constexpr uint64_t kLimitU64Undefined = …;
static constexpr uint32_t kMipLevelCountUndefined = …;
static constexpr uint32_t kQuerySetIndexUndefined = …;
static constexpr size_t kWholeMapSize = …;
static constexpr uint64_t kWholeSize = …;
enum class WGSLFeatureName : uint32_t { … };
static_assert …;
static_assert …;

enum class AdapterType : uint32_t { … };
static_assert …;
static_assert …;

enum class AddressMode : uint32_t { … };
static_assert …;
static_assert …;

enum class AlphaMode : uint32_t { … };
static_assert …;
static_assert …;

enum class BackendType : uint32_t { … };
static_assert …;
static_assert …;

enum class BlendFactor : uint32_t { … };
static_assert …;
static_assert …;

enum class BlendOperation : uint32_t { … };
static_assert …;
static_assert …;

enum class BufferBindingType : uint32_t { … };
static_assert …;
static_assert …;

enum class BufferMapAsyncStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class BufferMapState : uint32_t { … };
static_assert …;
static_assert …;

enum class CallbackMode : uint32_t { … };
static_assert …;
static_assert …;

enum class CompareFunction : uint32_t { … };
static_assert …;
static_assert …;

enum class CompilationInfoRequestStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class CompilationMessageType : uint32_t { … };
static_assert …;
static_assert …;

enum class CompositeAlphaMode : uint32_t { … };
static_assert …;
static_assert …;

enum class CreatePipelineAsyncStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class CullMode : uint32_t { … };
static_assert …;
static_assert …;

enum class DeviceLostReason : uint32_t { … };
static_assert …;
static_assert …;

enum class ErrorFilter : uint32_t { … };
static_assert …;
static_assert …;

enum class ErrorType : uint32_t { … };
static_assert …;
static_assert …;

enum class ExternalTextureRotation : uint32_t { … };
static_assert …;
static_assert …;

enum class FeatureName : uint32_t { … };
static_assert …;
static_assert …;

enum class FilterMode : uint32_t { … };
static_assert …;
static_assert …;

enum class FrontFace : uint32_t { … };
static_assert …;
static_assert …;

enum class IndexFormat : uint32_t { … };
static_assert …;
static_assert …;

enum class LoadOp : uint32_t { … };
static_assert …;
static_assert …;

enum class LoggingType : uint32_t { … };
static_assert …;
static_assert …;

enum class MapAsyncStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class MipmapFilterMode : uint32_t { … };
static_assert …;
static_assert …;

enum class PopErrorScopeStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class PowerPreference : uint32_t { … };
static_assert …;
static_assert …;

enum class PresentMode : uint32_t { … };
static_assert …;
static_assert …;

enum class PrimitiveTopology : uint32_t { … };
static_assert …;
static_assert …;

enum class QueryType : uint32_t { … };
static_assert …;
static_assert …;

enum class QueueWorkDoneStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class RequestAdapterStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class RequestDeviceStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class SType : uint32_t { … };
static_assert …;
static_assert …;

enum class SamplerBindingType : uint32_t { … };
static_assert …;
static_assert …;

enum class SharedFenceType : uint32_t { … };
static_assert …;
static_assert …;

enum class Status : uint32_t { … };
static_assert …;
static_assert …;

enum class StencilOperation : uint32_t { … };
static_assert …;
static_assert …;

enum class StorageTextureAccess : uint32_t { … };
static_assert …;
static_assert …;

enum class StoreOp : uint32_t { … };
static_assert …;
static_assert …;

enum class SurfaceGetCurrentTextureStatus : uint32_t { … };
static_assert …;
static_assert …;

enum class TextureAspect : uint32_t { … };
static_assert …;
static_assert …;

enum class TextureDimension : uint32_t { … };
static_assert …;
static_assert …;

enum class TextureFormat : uint32_t { … };
static_assert …;
static_assert …;

enum class TextureSampleType : uint32_t { … };
static_assert …;
static_assert …;

enum class TextureViewDimension : uint32_t { … };
static_assert …;
static_assert …;

enum class VertexFormat : uint32_t { … };
static_assert …;
static_assert …;

enum class VertexStepMode : uint32_t { … };
static_assert …;
static_assert …;

enum class WaitStatus : uint32_t { … };
static_assert …;
static_assert …;


enum class BufferUsage : uint64_t { … };
static_assert …;
static_assert …;

enum class ColorWriteMask : uint64_t { … };
static_assert …;
static_assert …;

enum class HeapProperty : uint64_t { … };
static_assert …;
static_assert …;

enum class MapMode : uint64_t { … };
static_assert …;
static_assert …;

enum class ShaderStage : uint64_t { … };
static_assert …;
static_assert …;

enum class TextureUsage : uint64_t { … };
static_assert …;
static_assert …;


// TODO(crbug.com/42241461): Update these to not be using the C callback types, and instead be
// defined using C++ types instead. Note that when we remove these, the C++ callback info types
// should also all be removed as they will no longer be necessary given the C++ templated
// functions calls and setter utilities.
BufferMapCallback;
Callback;
CompilationInfoCallback;
CreateComputePipelineAsyncCallback;
CreateRenderPipelineAsyncCallback;
DawnLoadCacheDataFunction;
DawnStoreCacheDataFunction;
DeviceLostCallback;
DeviceLostCallbackNew;
ErrorCallback;
LoggingCallback;
PopErrorScopeCallback;
Proc;
QueueWorkDoneCallback;
RequestAdapterCallback;
RequestDeviceCallback;

// Special class for booleans in order to allow implicit conversions.
class Bool { … };

// Special class for optional booleans in order to allow conversions.
class OptionalBool { … };
inline const OptionalBool OptionalBool::False = …;
inline const OptionalBool OptionalBool::True = …;
inline const OptionalBool OptionalBool::Undefined = …;

// Helper class to wrap Status which allows implicit conversion to bool.
// Used while callers switch to checking the Status enum instead of booleans.
// TODO(crbug.com/42241199): Remove when all callers check the enum.
struct ConvertibleStatus { … };

template<typename Derived, typename CType>
class ObjectBase { … };






class Adapter;
class BindGroup;
class BindGroupLayout;
class Buffer;
class CommandBuffer;
class CommandEncoder;
class ComputePassEncoder;
class ComputePipeline;
class Device;
class ExternalTexture;
class Instance;
class PipelineLayout;
class QuerySet;
class Queue;
class RenderBundle;
class RenderBundleEncoder;
class RenderPassEncoder;
class RenderPipeline;
class Sampler;
class ShaderModule;
class SharedBufferMemory;
class SharedFence;
class SharedTextureMemory;
class Surface;
class SwapChain;
class Texture;
class TextureView;

struct INTERNAL__HAVE_EMDAWNWEBGPU_HEADER;
struct AdapterInfo;
struct AdapterProperties;
struct AdapterPropertiesD3D;
struct AdapterPropertiesVk;
struct BindGroupEntry;
struct BlendComponent;
struct BufferBindingLayout;
struct BufferDescriptor;
struct BufferHostMappedPointer;
struct BufferMapCallbackInfo;
struct Color;
struct ColorTargetStateExpandResolveTextureDawn;
struct CommandBufferDescriptor;
struct CommandEncoderDescriptor;
struct CompilationInfoCallbackInfo;
struct CompilationMessage;
struct ComputePassTimestampWrites;
struct ConstantEntry;
struct CopyTextureForBrowserOptions;
struct CreateComputePipelineAsyncCallbackInfo;
struct CreateRenderPipelineAsyncCallbackInfo;
struct DawnWGSLBlocklist;
struct DawnAdapterPropertiesPowerPreference;
struct DawnBufferDescriptorErrorInfoFromWireClient;
struct DawnCacheDeviceDescriptor;
struct DawnComputePipelineFullSubgroups;
struct DawnEncoderInternalUsageDescriptor;
struct DawnExperimentalSubgroupLimits;
struct DawnRenderPassColorAttachmentRenderToSingleSampled;
struct DawnShaderModuleSPIRVOptionsDescriptor;
struct DawnTextureInternalUsageDescriptor;
struct DawnTogglesDescriptor;
struct DawnWireWGSLControl;
struct DeviceLostCallbackInfo;
struct DrmFormatProperties;
struct Extent2D;
struct Extent3D;
struct ExternalTextureBindingEntry;
struct ExternalTextureBindingLayout;
struct FormatCapabilities;
struct Future;
struct InstanceFeatures;
struct Limits;
struct MemoryHeapInfo;
struct MultisampleState;
struct NullableStringView;
struct Origin2D;
struct Origin3D;
struct PipelineLayoutDescriptor;
struct PipelineLayoutStorageAttachment;
struct PopErrorScopeCallbackInfo;
struct PrimitiveDepthClipControl;
struct PrimitiveState;
struct QuerySetDescriptor;
struct QueueDescriptor;
struct QueueWorkDoneCallbackInfo;
struct RenderBundleDescriptor;
struct RenderBundleEncoderDescriptor;
struct RenderPassDepthStencilAttachment;
struct RenderPassDescriptorExpandResolveRect;
struct RenderPassDescriptorMaxDrawCount;
struct RenderPassTimestampWrites;
struct RequestAdapterCallbackInfo;
struct RequestAdapterOptions;
struct RequestDeviceCallbackInfo;
struct SamplerBindingLayout;
struct SamplerDescriptor;
struct ShaderModuleSPIRVDescriptor;
struct ShaderModuleWGSLDescriptor;
struct ShaderModuleCompilationOptions;
struct ShaderModuleDescriptor;
struct SharedBufferMemoryBeginAccessDescriptor;
struct SharedBufferMemoryDescriptor;
struct SharedBufferMemoryEndAccessState;
struct SharedBufferMemoryProperties;
struct SharedFenceDXGISharedHandleDescriptor;
struct SharedFenceDXGISharedHandleExportInfo;
struct SharedFenceMTLSharedEventDescriptor;
struct SharedFenceMTLSharedEventExportInfo;
struct SharedFenceDescriptor;
struct SharedFenceExportInfo;
struct SharedFenceVkSemaphoreOpaqueFDDescriptor;
struct SharedFenceVkSemaphoreOpaqueFDExportInfo;
struct SharedFenceVkSemaphoreSyncFDDescriptor;
struct SharedFenceVkSemaphoreSyncFDExportInfo;
struct SharedFenceVkSemaphoreZirconHandleDescriptor;
struct SharedFenceVkSemaphoreZirconHandleExportInfo;
struct SharedTextureMemoryD3DSwapchainBeginState;
struct SharedTextureMemoryDXGISharedHandleDescriptor;
struct SharedTextureMemoryEGLImageDescriptor;
struct SharedTextureMemoryIOSurfaceDescriptor;
struct SharedTextureMemoryAHardwareBufferDescriptor;
struct SharedTextureMemoryBeginAccessDescriptor;
struct SharedTextureMemoryDescriptor;
struct SharedTextureMemoryDmaBufPlane;
struct SharedTextureMemoryEndAccessState;
struct SharedTextureMemoryOpaqueFDDescriptor;
struct SharedTextureMemoryVkDedicatedAllocationDescriptor;
struct SharedTextureMemoryVkImageLayoutBeginState;
struct SharedTextureMemoryVkImageLayoutEndState;
struct SharedTextureMemoryZirconHandleDescriptor;
struct StaticSamplerBindingLayout;
struct StencilFaceState;
struct StorageTextureBindingLayout;
struct StringView;
struct SurfaceCapabilities;
struct SurfaceConfiguration;
struct SurfaceDescriptor;
struct SurfaceDescriptorFromAndroidNativeWindow;
struct SurfaceDescriptorFromCanvasHTMLSelector;
struct SurfaceDescriptorFromMetalLayer;
struct SurfaceDescriptorFromWaylandSurface;
struct SurfaceDescriptorFromWindowsHWND;
struct SurfaceDescriptorFromWindowsCoreWindow;
struct SurfaceDescriptorFromWindowsSwapChainPanel;
struct SurfaceDescriptorFromXcbWindow;
struct SurfaceDescriptorFromXlibWindow;
struct SurfaceTexture;
struct SwapChainDescriptor;
struct TextureBindingLayout;
struct TextureBindingViewDimensionDescriptor;
struct TextureDataLayout;
struct TextureViewDescriptor;
struct UncapturedErrorCallbackInfo;
struct VertexAttribute;
struct YCbCrVkDescriptor;
struct AHardwareBufferProperties;
struct AdapterPropertiesMemoryHeaps;
struct BindGroupDescriptor;
struct BindGroupLayoutEntry;
struct BlendState;
struct CompilationInfo;
struct ComputePassDescriptor;
struct DepthStencilState;
struct DrmFormatCapabilities;
struct ExternalTextureDescriptor;
struct FutureWaitInfo;
struct ImageCopyBuffer;
struct ImageCopyExternalTexture;
struct ImageCopyTexture;
struct InstanceDescriptor;
struct PipelineLayoutPixelLocalStorage;
struct ProgrammableStageDescriptor;
struct RenderPassColorAttachment;
struct RenderPassStorageAttachment;
struct RequiredLimits;
struct SharedTextureMemoryAHardwareBufferProperties;
struct SharedTextureMemoryDmaBufDescriptor;
struct SharedTextureMemoryProperties;
struct SupportedLimits;
struct TextureDescriptor;
struct VertexBufferLayout;
struct BindGroupLayoutDescriptor;
struct ColorTargetState;
struct ComputePipelineDescriptor;
struct DeviceDescriptor;
struct RenderPassDescriptor;
struct RenderPassPixelLocalStorage;
struct VertexState;
struct FragmentState;
struct RenderPipelineDescriptor;




class Adapter : public ObjectBase<Adapter, WGPUAdapter> { … };

class BindGroup : public ObjectBase<BindGroup, WGPUBindGroup> { … };

class BindGroupLayout : public ObjectBase<BindGroupLayout, WGPUBindGroupLayout> { … };

class Buffer : public ObjectBase<Buffer, WGPUBuffer> { … };

class CommandBuffer : public ObjectBase<CommandBuffer, WGPUCommandBuffer> { … };

class CommandEncoder : public ObjectBase<CommandEncoder, WGPUCommandEncoder> { … };

class ComputePassEncoder : public ObjectBase<ComputePassEncoder, WGPUComputePassEncoder> { … };

class ComputePipeline : public ObjectBase<ComputePipeline, WGPUComputePipeline> { … };

class Device : public ObjectBase<Device, WGPUDevice> { … };

class ExternalTexture : public ObjectBase<ExternalTexture, WGPUExternalTexture> { … };

class Instance : public ObjectBase<Instance, WGPUInstance> { … };

class PipelineLayout : public ObjectBase<PipelineLayout, WGPUPipelineLayout> { … };

class QuerySet : public ObjectBase<QuerySet, WGPUQuerySet> { … };

class Queue : public ObjectBase<Queue, WGPUQueue> { … };

class RenderBundle : public ObjectBase<RenderBundle, WGPURenderBundle> { … };

class RenderBundleEncoder : public ObjectBase<RenderBundleEncoder, WGPURenderBundleEncoder> { … };

class RenderPassEncoder : public ObjectBase<RenderPassEncoder, WGPURenderPassEncoder> { … };

class RenderPipeline : public ObjectBase<RenderPipeline, WGPURenderPipeline> { … };

class Sampler : public ObjectBase<Sampler, WGPUSampler> { … };

class ShaderModule : public ObjectBase<ShaderModule, WGPUShaderModule> { … };

class SharedBufferMemory : public ObjectBase<SharedBufferMemory, WGPUSharedBufferMemory> { … };

class SharedFence : public ObjectBase<SharedFence, WGPUSharedFence> { … };

class SharedTextureMemory : public ObjectBase<SharedTextureMemory, WGPUSharedTextureMemory> { … };

class Surface : public ObjectBase<Surface, WGPUSurface> { … };

class SwapChain : public ObjectBase<SwapChain, WGPUSwapChain> { … };

class Texture : public ObjectBase<Texture, WGPUTexture> { … };

class TextureView : public ObjectBase<TextureView, WGPUTextureView> { … };


// ChainedStruct
static_assert …;
static_assert …;
static_assert …;
static_assert …;


struct INTERNAL__HAVE_EMDAWNWEBGPU_HEADER { … };

struct AdapterInfo { … };

struct AdapterProperties { … };

// Can be chained in AdapterInfo
// Can be chained in AdapterProperties
struct AdapterPropertiesD3D : ChainedStructOut { … };

// Can be chained in AdapterInfo
// Can be chained in AdapterProperties
struct AdapterPropertiesVk : ChainedStructOut { … };

struct BindGroupEntry { … };

struct BlendComponent { … };

struct BufferBindingLayout { … };

struct BufferDescriptor { … };

// Can be chained in BufferDescriptor
struct BufferHostMappedPointer : ChainedStruct { … };

struct BufferMapCallbackInfo { … };

struct Color { … };

// Can be chained in ColorTargetState
struct ColorTargetStateExpandResolveTextureDawn : ChainedStruct { … };

struct CommandBufferDescriptor { … };

struct CommandEncoderDescriptor { … };

struct CompilationInfoCallbackInfo { … };

struct CompilationMessage { … };

struct ComputePassTimestampWrites { … };

struct ConstantEntry { … };

struct CopyTextureForBrowserOptions { … };

struct CreateComputePipelineAsyncCallbackInfo { … };

struct CreateRenderPipelineAsyncCallbackInfo { … };

// Can be chained in InstanceDescriptor
struct DawnWGSLBlocklist : ChainedStruct { … };

// Can be chained in AdapterInfo
// Can be chained in AdapterProperties
struct DawnAdapterPropertiesPowerPreference : ChainedStructOut { … };

// Can be chained in BufferDescriptor
struct DawnBufferDescriptorErrorInfoFromWireClient : ChainedStruct { … };

// Can be chained in DeviceDescriptor
struct DawnCacheDeviceDescriptor : ChainedStruct { … };

// Can be chained in ComputePipelineDescriptor
struct DawnComputePipelineFullSubgroups : ChainedStruct { … };

// Can be chained in CommandEncoderDescriptor
struct DawnEncoderInternalUsageDescriptor : ChainedStruct { … };

// Can be chained in SupportedLimits
struct DawnExperimentalSubgroupLimits : ChainedStructOut { … };

// Can be chained in RenderPassColorAttachment
struct DawnRenderPassColorAttachmentRenderToSingleSampled : ChainedStruct { … };

// Can be chained in ShaderModuleDescriptor
struct DawnShaderModuleSPIRVOptionsDescriptor : ChainedStruct { … };

// Can be chained in TextureDescriptor
struct DawnTextureInternalUsageDescriptor : ChainedStruct { … };

// Can be chained in InstanceDescriptor
// Can be chained in RequestAdapterOptions
// Can be chained in DeviceDescriptor
struct DawnTogglesDescriptor : ChainedStruct { … };

// Can be chained in InstanceDescriptor
struct DawnWireWGSLControl : ChainedStruct { … };

struct DeviceLostCallbackInfo { … };

struct DrmFormatProperties { … };

struct Extent2D { … };

struct Extent3D { … };

// Can be chained in BindGroupEntry
struct ExternalTextureBindingEntry : ChainedStruct { … };

// Can be chained in BindGroupLayoutEntry
struct ExternalTextureBindingLayout : ChainedStruct { … };

struct FormatCapabilities { … };

struct Future { … };

struct InstanceFeatures { … };

struct Limits { … };

struct MemoryHeapInfo { … };

struct MultisampleState { … };

struct NullableStringView { … };

struct Origin2D { … };

struct Origin3D { … };

struct PipelineLayoutDescriptor { … };

struct PipelineLayoutStorageAttachment { … };

struct PopErrorScopeCallbackInfo { … };

// Can be chained in PrimitiveState
struct PrimitiveDepthClipControl : ChainedStruct { … };

struct PrimitiveState { … };

struct QuerySetDescriptor { … };

struct QueueDescriptor { … };

struct QueueWorkDoneCallbackInfo { … };

struct RenderBundleDescriptor { … };

struct RenderBundleEncoderDescriptor { … };

struct RenderPassDepthStencilAttachment { … };

// Can be chained in RenderPassDescriptor
struct RenderPassDescriptorExpandResolveRect : ChainedStruct { … };

// Can be chained in RenderPassDescriptor
struct RenderPassDescriptorMaxDrawCount : ChainedStruct { … };

struct RenderPassTimestampWrites { … };

struct RequestAdapterCallbackInfo { … };

struct RequestAdapterOptions { … };

struct RequestDeviceCallbackInfo { … };

struct SamplerBindingLayout { … };

struct SamplerDescriptor { … };

// Can be chained in ShaderModuleDescriptor
struct ShaderModuleSPIRVDescriptor : ChainedStruct { … };

// Can be chained in ShaderModuleDescriptor
struct ShaderModuleWGSLDescriptor : ChainedStruct { … };

// Can be chained in ShaderModuleDescriptor
struct ShaderModuleCompilationOptions : ChainedStruct { … };

struct ShaderModuleDescriptor { … };

struct SharedBufferMemoryBeginAccessDescriptor { … };

struct SharedBufferMemoryDescriptor { … };

struct SharedBufferMemoryEndAccessState { … };

struct SharedBufferMemoryProperties { … };

// Can be chained in SharedFenceDescriptor
struct SharedFenceDXGISharedHandleDescriptor : ChainedStruct { … };

// Can be chained in SharedFenceExportInfo
struct SharedFenceDXGISharedHandleExportInfo : ChainedStructOut { … };

// Can be chained in SharedFenceDescriptor
struct SharedFenceMTLSharedEventDescriptor : ChainedStruct { … };

// Can be chained in SharedFenceExportInfo
struct SharedFenceMTLSharedEventExportInfo : ChainedStructOut { … };

struct SharedFenceDescriptor { … };

struct SharedFenceExportInfo { … };

// Can be chained in SharedFenceDescriptor
struct SharedFenceVkSemaphoreOpaqueFDDescriptor : ChainedStruct { … };

// Can be chained in SharedFenceExportInfo
struct SharedFenceVkSemaphoreOpaqueFDExportInfo : ChainedStructOut { … };

// Can be chained in SharedFenceDescriptor
struct SharedFenceVkSemaphoreSyncFDDescriptor : ChainedStruct { … };

// Can be chained in SharedFenceExportInfo
struct SharedFenceVkSemaphoreSyncFDExportInfo : ChainedStructOut { … };

// Can be chained in SharedFenceDescriptor
struct SharedFenceVkSemaphoreZirconHandleDescriptor : ChainedStruct { … };

// Can be chained in SharedFenceExportInfo
struct SharedFenceVkSemaphoreZirconHandleExportInfo : ChainedStructOut { … };

// Can be chained in SharedTextureMemoryBeginAccessDescriptor
struct SharedTextureMemoryD3DSwapchainBeginState : ChainedStruct { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryDXGISharedHandleDescriptor : ChainedStruct { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryEGLImageDescriptor : ChainedStruct { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryIOSurfaceDescriptor : ChainedStruct { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct { … };

struct SharedTextureMemoryBeginAccessDescriptor { … };

struct SharedTextureMemoryDescriptor { … };

struct SharedTextureMemoryDmaBufPlane { … };

struct SharedTextureMemoryEndAccessState { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryOpaqueFDDescriptor : ChainedStruct { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryVkDedicatedAllocationDescriptor : ChainedStruct { … };

// Can be chained in SharedTextureMemoryBeginAccessDescriptor
struct SharedTextureMemoryVkImageLayoutBeginState : ChainedStruct { … };

// Can be chained in SharedTextureMemoryEndAccessState
struct SharedTextureMemoryVkImageLayoutEndState : ChainedStructOut { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryZirconHandleDescriptor : ChainedStruct { … };

// Can be chained in BindGroupLayoutEntry
struct StaticSamplerBindingLayout : ChainedStruct { … };

struct StencilFaceState { … };

struct StorageTextureBindingLayout { … };

struct StringView { … };

struct SurfaceCapabilities { … };

struct SurfaceConfiguration { … };

struct SurfaceDescriptor { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromAndroidNativeWindow : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromCanvasHTMLSelector : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromMetalLayer : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromWaylandSurface : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromWindowsHWND : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromWindowsCoreWindow : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromWindowsSwapChainPanel : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromXcbWindow : ChainedStruct { … };

// Can be chained in SurfaceDescriptor
struct SurfaceDescriptorFromXlibWindow : ChainedStruct { … };

struct SurfaceTexture { … };

struct SwapChainDescriptor { … };

struct TextureBindingLayout { … };

// Can be chained in TextureDescriptor
struct TextureBindingViewDimensionDescriptor : ChainedStruct { … };

struct TextureDataLayout { … };

struct TextureViewDescriptor { … };

struct UncapturedErrorCallbackInfo { … };

struct VertexAttribute { … };

// Can be chained in SamplerDescriptor
// Can be chained in TextureViewDescriptor
struct YCbCrVkDescriptor : ChainedStruct { … };

struct AHardwareBufferProperties { … };

// Can be chained in AdapterInfo
// Can be chained in AdapterProperties
struct AdapterPropertiesMemoryHeaps : ChainedStructOut { … };

struct BindGroupDescriptor { … };

struct BindGroupLayoutEntry { … };

struct BlendState { … };

struct CompilationInfo { … };

struct ComputePassDescriptor { … };

struct DepthStencilState { … };

// Can be chained in FormatCapabilities
struct DrmFormatCapabilities : ChainedStructOut { … };

struct ExternalTextureDescriptor { … };

struct FutureWaitInfo { … };

struct ImageCopyBuffer { … };

struct ImageCopyExternalTexture { … };

struct ImageCopyTexture { … };

struct InstanceDescriptor { … };

// Can be chained in PipelineLayoutDescriptor
struct PipelineLayoutPixelLocalStorage : ChainedStruct { … };

struct ProgrammableStageDescriptor { … };

struct RenderPassColorAttachment { … };

struct RenderPassStorageAttachment { … };

struct RequiredLimits { … };

// Can be chained in SharedTextureMemoryProperties
struct SharedTextureMemoryAHardwareBufferProperties : ChainedStructOut { … };

// Can be chained in SharedTextureMemoryDescriptor
struct SharedTextureMemoryDmaBufDescriptor : ChainedStruct { … };

struct SharedTextureMemoryProperties { … };

struct SupportedLimits { … };

struct TextureDescriptor { … };

struct VertexBufferLayout { … };

struct BindGroupLayoutDescriptor { … };

struct ColorTargetState { … };

struct ComputePipelineDescriptor { … };

struct RenderPassDescriptor { … };

// Can be chained in RenderPassDescriptor
struct RenderPassPixelLocalStorage : ChainedStruct { … };

struct VertexState { … };

struct FragmentState { … };

struct RenderPipelineDescriptor { … };


namespace detail {
struct DeviceDescriptor { … };
}  // namespace detail
struct DeviceDescriptor : protected detail::DeviceDescriptor { … };

#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
// error: 'offsetof' within non-standard-layout type 'wgpu::XXX' is conditionally-supported
#pragma GCC diagnostic ignored "-Winvalid-offsetof"
#endif

// INTERNAL__HAVE_EMDAWNWEBGPU_HEADER implementation

operator const WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER &()

static_assert …;
static_assert …;

// AdapterInfo implementation
AdapterInfo::AdapterInfo() = default;
AdapterInfo::~AdapterInfo() { … }

AdapterInfo::AdapterInfo(AdapterInfo&& rhs)
    : … { … }

AdapterInfo& AdapterInfo::operator=(AdapterInfo&& rhs) { … }

void AdapterInfo::FreeMembers() { … }

// static
void AdapterInfo::Reset(AdapterInfo& value) { … }

operator const WGPUAdapterInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// AdapterProperties implementation
AdapterProperties::AdapterProperties() = default;
AdapterProperties::~AdapterProperties() { … }

AdapterProperties::AdapterProperties(AdapterProperties&& rhs)
    : … { … }

AdapterProperties& AdapterProperties::operator=(AdapterProperties&& rhs) { … }

void AdapterProperties::FreeMembers() { … }

// static
void AdapterProperties::Reset(AdapterProperties& value) { … }

operator const WGPUAdapterProperties &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// AdapterPropertiesD3D implementation
AdapterPropertiesD3D::AdapterPropertiesD3D()
  : … { … }
struct AdapterPropertiesD3D::Init { … };
AdapterPropertiesD3D::AdapterPropertiesD3D(AdapterPropertiesD3D::Init&& init)
  : … { … }

operator const WGPUAdapterPropertiesD3D &()

static_assert …;
static_assert …;
static_assert …;

// AdapterPropertiesVk implementation
AdapterPropertiesVk::AdapterPropertiesVk()
  : … { … }
struct AdapterPropertiesVk::Init { … };
AdapterPropertiesVk::AdapterPropertiesVk(AdapterPropertiesVk::Init&& init)
  : … { … }

operator const WGPUAdapterPropertiesVk &()

static_assert …;
static_assert …;
static_assert …;

// BindGroupEntry implementation

operator const WGPUBindGroupEntry &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BlendComponent implementation

operator const WGPUBlendComponent &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BufferBindingLayout implementation

operator const WGPUBufferBindingLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BufferDescriptor implementation

operator const WGPUBufferDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BufferHostMappedPointer implementation
BufferHostMappedPointer::BufferHostMappedPointer()
  : … { … }
struct BufferHostMappedPointer::Init { … };
BufferHostMappedPointer::BufferHostMappedPointer(BufferHostMappedPointer::Init&& init)
  : … { … }

operator const WGPUBufferHostMappedPointer &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BufferMapCallbackInfo implementation

operator const WGPUBufferMapCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// Color implementation

operator const WGPUColor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ColorTargetStateExpandResolveTextureDawn implementation
ColorTargetStateExpandResolveTextureDawn::ColorTargetStateExpandResolveTextureDawn()
  : … { … }
struct ColorTargetStateExpandResolveTextureDawn::Init { … };
ColorTargetStateExpandResolveTextureDawn::ColorTargetStateExpandResolveTextureDawn(ColorTargetStateExpandResolveTextureDawn::Init&& init)
  : … { … }

operator const WGPUColorTargetStateExpandResolveTextureDawn &()

static_assert …;
static_assert …;
static_assert …;

// CommandBufferDescriptor implementation

operator const WGPUCommandBufferDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CommandEncoderDescriptor implementation

operator const WGPUCommandEncoderDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CompilationInfoCallbackInfo implementation

operator const WGPUCompilationInfoCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CompilationMessage implementation

operator const WGPUCompilationMessage &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ComputePassTimestampWrites implementation

operator const WGPUComputePassTimestampWrites &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ConstantEntry implementation

operator const WGPUConstantEntry &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CopyTextureForBrowserOptions implementation

operator const WGPUCopyTextureForBrowserOptions &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CreateComputePipelineAsyncCallbackInfo implementation

operator const WGPUCreateComputePipelineAsyncCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CreateRenderPipelineAsyncCallbackInfo implementation

operator const WGPUCreateRenderPipelineAsyncCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DawnWGSLBlocklist implementation
DawnWGSLBlocklist::DawnWGSLBlocklist()
  : … { … }
struct DawnWGSLBlocklist::Init { … };
DawnWGSLBlocklist::DawnWGSLBlocklist(DawnWGSLBlocklist::Init&& init)
  : … { … }

operator const WGPUDawnWGSLBlocklist &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DawnAdapterPropertiesPowerPreference implementation
DawnAdapterPropertiesPowerPreference::DawnAdapterPropertiesPowerPreference()
  : … { … }
struct DawnAdapterPropertiesPowerPreference::Init { … };
DawnAdapterPropertiesPowerPreference::DawnAdapterPropertiesPowerPreference(DawnAdapterPropertiesPowerPreference::Init&& init)
  : … { … }

operator const WGPUDawnAdapterPropertiesPowerPreference &()

static_assert …;
static_assert …;
static_assert …;

// DawnBufferDescriptorErrorInfoFromWireClient implementation
DawnBufferDescriptorErrorInfoFromWireClient::DawnBufferDescriptorErrorInfoFromWireClient()
  : … { … }
struct DawnBufferDescriptorErrorInfoFromWireClient::Init { … };
DawnBufferDescriptorErrorInfoFromWireClient::DawnBufferDescriptorErrorInfoFromWireClient(DawnBufferDescriptorErrorInfoFromWireClient::Init&& init)
  : … { … }

operator const WGPUDawnBufferDescriptorErrorInfoFromWireClient &()

static_assert …;
static_assert …;
static_assert …;

// DawnCacheDeviceDescriptor implementation
DawnCacheDeviceDescriptor::DawnCacheDeviceDescriptor()
  : … { … }
struct DawnCacheDeviceDescriptor::Init { … };
DawnCacheDeviceDescriptor::DawnCacheDeviceDescriptor(DawnCacheDeviceDescriptor::Init&& init)
  : … { … }

operator const WGPUDawnCacheDeviceDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DawnComputePipelineFullSubgroups implementation
DawnComputePipelineFullSubgroups::DawnComputePipelineFullSubgroups()
  : … { … }
struct DawnComputePipelineFullSubgroups::Init { … };
DawnComputePipelineFullSubgroups::DawnComputePipelineFullSubgroups(DawnComputePipelineFullSubgroups::Init&& init)
  : … { … }

operator const WGPUDawnComputePipelineFullSubgroups &()

static_assert …;
static_assert …;
static_assert …;

// DawnEncoderInternalUsageDescriptor implementation
DawnEncoderInternalUsageDescriptor::DawnEncoderInternalUsageDescriptor()
  : … { … }
struct DawnEncoderInternalUsageDescriptor::Init { … };
DawnEncoderInternalUsageDescriptor::DawnEncoderInternalUsageDescriptor(DawnEncoderInternalUsageDescriptor::Init&& init)
  : … { … }

operator const WGPUDawnEncoderInternalUsageDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// DawnExperimentalSubgroupLimits implementation
DawnExperimentalSubgroupLimits::DawnExperimentalSubgroupLimits()
  : … { … }
struct DawnExperimentalSubgroupLimits::Init { … };
DawnExperimentalSubgroupLimits::DawnExperimentalSubgroupLimits(DawnExperimentalSubgroupLimits::Init&& init)
  : … { … }

operator const WGPUDawnExperimentalSubgroupLimits &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DawnRenderPassColorAttachmentRenderToSingleSampled implementation
DawnRenderPassColorAttachmentRenderToSingleSampled::DawnRenderPassColorAttachmentRenderToSingleSampled()
  : … { … }
struct DawnRenderPassColorAttachmentRenderToSingleSampled::Init { … };
DawnRenderPassColorAttachmentRenderToSingleSampled::DawnRenderPassColorAttachmentRenderToSingleSampled(DawnRenderPassColorAttachmentRenderToSingleSampled::Init&& init)
  : … { … }

operator const WGPUDawnRenderPassColorAttachmentRenderToSingleSampled &()

static_assert …;
static_assert …;
static_assert …;

// DawnShaderModuleSPIRVOptionsDescriptor implementation
DawnShaderModuleSPIRVOptionsDescriptor::DawnShaderModuleSPIRVOptionsDescriptor()
  : … { … }
struct DawnShaderModuleSPIRVOptionsDescriptor::Init { … };
DawnShaderModuleSPIRVOptionsDescriptor::DawnShaderModuleSPIRVOptionsDescriptor(DawnShaderModuleSPIRVOptionsDescriptor::Init&& init)
  : … { … }

operator const WGPUDawnShaderModuleSPIRVOptionsDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// DawnTextureInternalUsageDescriptor implementation
DawnTextureInternalUsageDescriptor::DawnTextureInternalUsageDescriptor()
  : … { … }
struct DawnTextureInternalUsageDescriptor::Init { … };
DawnTextureInternalUsageDescriptor::DawnTextureInternalUsageDescriptor(DawnTextureInternalUsageDescriptor::Init&& init)
  : … { … }

operator const WGPUDawnTextureInternalUsageDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// DawnTogglesDescriptor implementation
DawnTogglesDescriptor::DawnTogglesDescriptor()
  : … { … }
struct DawnTogglesDescriptor::Init { … };
DawnTogglesDescriptor::DawnTogglesDescriptor(DawnTogglesDescriptor::Init&& init)
  : … { … }

operator const WGPUDawnTogglesDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DawnWireWGSLControl implementation
DawnWireWGSLControl::DawnWireWGSLControl()
  : … { … }
struct DawnWireWGSLControl::Init { … };
DawnWireWGSLControl::DawnWireWGSLControl(DawnWireWGSLControl::Init&& init)
  : … { … }

operator const WGPUDawnWireWGSLControl &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DeviceLostCallbackInfo implementation

operator const WGPUDeviceLostCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DrmFormatProperties implementation

operator const WGPUDrmFormatProperties &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// Extent2D implementation

operator const WGPUExtent2D &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// Extent3D implementation

operator const WGPUExtent3D &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ExternalTextureBindingEntry implementation
ExternalTextureBindingEntry::ExternalTextureBindingEntry()
  : … { … }
struct ExternalTextureBindingEntry::Init { … };
ExternalTextureBindingEntry::ExternalTextureBindingEntry(ExternalTextureBindingEntry::Init&& init)
  : … { … }

operator const WGPUExternalTextureBindingEntry &()

static_assert …;
static_assert …;
static_assert …;

// ExternalTextureBindingLayout implementation
ExternalTextureBindingLayout::ExternalTextureBindingLayout()
  : … { … }
struct ExternalTextureBindingLayout::Init { … };
ExternalTextureBindingLayout::ExternalTextureBindingLayout(ExternalTextureBindingLayout::Init&& init)
  : … { … }

operator const WGPUExternalTextureBindingLayout &()

static_assert …;
static_assert …;

// FormatCapabilities implementation

operator const WGPUFormatCapabilities &()

static_assert …;
static_assert …;
static_assert …;

// Future implementation

operator const WGPUFuture &()

static_assert …;
static_assert …;
static_assert …;

// InstanceFeatures implementation

operator const WGPUInstanceFeatures &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// Limits implementation

operator const WGPULimits &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// MemoryHeapInfo implementation

operator const WGPUMemoryHeapInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// MultisampleState implementation

operator const WGPUMultisampleState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// NullableStringView implementation

operator const WGPUStringView &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// Origin2D implementation

operator const WGPUOrigin2D &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// Origin3D implementation

operator const WGPUOrigin3D &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// PipelineLayoutDescriptor implementation

operator const WGPUPipelineLayoutDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// PipelineLayoutStorageAttachment implementation

operator const WGPUPipelineLayoutStorageAttachment &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// PopErrorScopeCallbackInfo implementation

operator const WGPUPopErrorScopeCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// PrimitiveDepthClipControl implementation
PrimitiveDepthClipControl::PrimitiveDepthClipControl()
  : … { … }
struct PrimitiveDepthClipControl::Init { … };
PrimitiveDepthClipControl::PrimitiveDepthClipControl(PrimitiveDepthClipControl::Init&& init)
  : … { … }

operator const WGPUPrimitiveDepthClipControl &()

static_assert …;
static_assert …;
static_assert …;

// PrimitiveState implementation

operator const WGPUPrimitiveState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// QuerySetDescriptor implementation

operator const WGPUQuerySetDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// QueueDescriptor implementation

operator const WGPUQueueDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// QueueWorkDoneCallbackInfo implementation

operator const WGPUQueueWorkDoneCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderBundleDescriptor implementation

operator const WGPURenderBundleDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderBundleEncoderDescriptor implementation

operator const WGPURenderBundleEncoderDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassDepthStencilAttachment implementation

operator const WGPURenderPassDepthStencilAttachment &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassDescriptorExpandResolveRect implementation
RenderPassDescriptorExpandResolveRect::RenderPassDescriptorExpandResolveRect()
  : … { … }
struct RenderPassDescriptorExpandResolveRect::Init { … };
RenderPassDescriptorExpandResolveRect::RenderPassDescriptorExpandResolveRect(RenderPassDescriptorExpandResolveRect::Init&& init)
  : … { … }

operator const WGPURenderPassDescriptorExpandResolveRect &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassDescriptorMaxDrawCount implementation
RenderPassDescriptorMaxDrawCount::RenderPassDescriptorMaxDrawCount()
  : … { … }
struct RenderPassDescriptorMaxDrawCount::Init { … };
RenderPassDescriptorMaxDrawCount::RenderPassDescriptorMaxDrawCount(RenderPassDescriptorMaxDrawCount::Init&& init)
  : … { … }

operator const WGPURenderPassDescriptorMaxDrawCount &()

static_assert …;
static_assert …;
static_assert …;

// RenderPassTimestampWrites implementation

operator const WGPURenderPassTimestampWrites &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RequestAdapterCallbackInfo implementation

operator const WGPURequestAdapterCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RequestAdapterOptions implementation

operator const WGPURequestAdapterOptions &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RequestDeviceCallbackInfo implementation

operator const WGPURequestDeviceCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SamplerBindingLayout implementation

operator const WGPUSamplerBindingLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SamplerDescriptor implementation

operator const WGPUSamplerDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ShaderModuleSPIRVDescriptor implementation
ShaderModuleSPIRVDescriptor::ShaderModuleSPIRVDescriptor()
  : … { … }
struct ShaderModuleSPIRVDescriptor::Init { … };
ShaderModuleSPIRVDescriptor::ShaderModuleSPIRVDescriptor(ShaderModuleSPIRVDescriptor::Init&& init)
  : … { … }

operator const WGPUShaderModuleSPIRVDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ShaderModuleWGSLDescriptor implementation
ShaderModuleWGSLDescriptor::ShaderModuleWGSLDescriptor()
  : … { … }
struct ShaderModuleWGSLDescriptor::Init { … };
ShaderModuleWGSLDescriptor::ShaderModuleWGSLDescriptor(ShaderModuleWGSLDescriptor::Init&& init)
  : … { … }

operator const WGPUShaderModuleWGSLDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// ShaderModuleCompilationOptions implementation
ShaderModuleCompilationOptions::ShaderModuleCompilationOptions()
  : … { … }
struct ShaderModuleCompilationOptions::Init { … };
ShaderModuleCompilationOptions::ShaderModuleCompilationOptions(ShaderModuleCompilationOptions::Init&& init)
  : … { … }

operator const WGPUShaderModuleCompilationOptions &()

static_assert …;
static_assert …;
static_assert …;

// ShaderModuleDescriptor implementation

operator const WGPUShaderModuleDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedBufferMemoryBeginAccessDescriptor implementation

operator const WGPUSharedBufferMemoryBeginAccessDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedBufferMemoryDescriptor implementation

operator const WGPUSharedBufferMemoryDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedBufferMemoryEndAccessState implementation
SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState() = default;
SharedBufferMemoryEndAccessState::~SharedBufferMemoryEndAccessState() { … }

SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState(SharedBufferMemoryEndAccessState&& rhs)
    : … { … }

SharedBufferMemoryEndAccessState& SharedBufferMemoryEndAccessState::operator=(SharedBufferMemoryEndAccessState&& rhs) { … }

void SharedBufferMemoryEndAccessState::FreeMembers() { … }

// static
void SharedBufferMemoryEndAccessState::Reset(SharedBufferMemoryEndAccessState& value) { … }

operator const WGPUSharedBufferMemoryEndAccessState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedBufferMemoryProperties implementation

operator const WGPUSharedBufferMemoryProperties &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedFenceDXGISharedHandleDescriptor implementation
SharedFenceDXGISharedHandleDescriptor::SharedFenceDXGISharedHandleDescriptor()
  : … { … }
struct SharedFenceDXGISharedHandleDescriptor::Init { … };
SharedFenceDXGISharedHandleDescriptor::SharedFenceDXGISharedHandleDescriptor(SharedFenceDXGISharedHandleDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedFenceDXGISharedHandleDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceDXGISharedHandleExportInfo implementation
SharedFenceDXGISharedHandleExportInfo::SharedFenceDXGISharedHandleExportInfo()
  : … { … }
struct SharedFenceDXGISharedHandleExportInfo::Init { … };
SharedFenceDXGISharedHandleExportInfo::SharedFenceDXGISharedHandleExportInfo(SharedFenceDXGISharedHandleExportInfo::Init&& init)
  : … { … }

operator const WGPUSharedFenceDXGISharedHandleExportInfo &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceMTLSharedEventDescriptor implementation
SharedFenceMTLSharedEventDescriptor::SharedFenceMTLSharedEventDescriptor()
  : … { … }
struct SharedFenceMTLSharedEventDescriptor::Init { … };
SharedFenceMTLSharedEventDescriptor::SharedFenceMTLSharedEventDescriptor(SharedFenceMTLSharedEventDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedFenceMTLSharedEventDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceMTLSharedEventExportInfo implementation
SharedFenceMTLSharedEventExportInfo::SharedFenceMTLSharedEventExportInfo()
  : … { … }
struct SharedFenceMTLSharedEventExportInfo::Init { … };
SharedFenceMTLSharedEventExportInfo::SharedFenceMTLSharedEventExportInfo(SharedFenceMTLSharedEventExportInfo::Init&& init)
  : … { … }

operator const WGPUSharedFenceMTLSharedEventExportInfo &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceDescriptor implementation

operator const WGPUSharedFenceDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedFenceExportInfo implementation

operator const WGPUSharedFenceExportInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedFenceVkSemaphoreOpaqueFDDescriptor implementation
SharedFenceVkSemaphoreOpaqueFDDescriptor::SharedFenceVkSemaphoreOpaqueFDDescriptor()
  : … { … }
struct SharedFenceVkSemaphoreOpaqueFDDescriptor::Init { … };
SharedFenceVkSemaphoreOpaqueFDDescriptor::SharedFenceVkSemaphoreOpaqueFDDescriptor(SharedFenceVkSemaphoreOpaqueFDDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceVkSemaphoreOpaqueFDExportInfo implementation
SharedFenceVkSemaphoreOpaqueFDExportInfo::SharedFenceVkSemaphoreOpaqueFDExportInfo()
  : … { … }
struct SharedFenceVkSemaphoreOpaqueFDExportInfo::Init { … };
SharedFenceVkSemaphoreOpaqueFDExportInfo::SharedFenceVkSemaphoreOpaqueFDExportInfo(SharedFenceVkSemaphoreOpaqueFDExportInfo::Init&& init)
  : … { … }

operator const WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceVkSemaphoreSyncFDDescriptor implementation
SharedFenceVkSemaphoreSyncFDDescriptor::SharedFenceVkSemaphoreSyncFDDescriptor()
  : … { … }
struct SharedFenceVkSemaphoreSyncFDDescriptor::Init { … };
SharedFenceVkSemaphoreSyncFDDescriptor::SharedFenceVkSemaphoreSyncFDDescriptor(SharedFenceVkSemaphoreSyncFDDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedFenceVkSemaphoreSyncFDDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceVkSemaphoreSyncFDExportInfo implementation
SharedFenceVkSemaphoreSyncFDExportInfo::SharedFenceVkSemaphoreSyncFDExportInfo()
  : … { … }
struct SharedFenceVkSemaphoreSyncFDExportInfo::Init { … };
SharedFenceVkSemaphoreSyncFDExportInfo::SharedFenceVkSemaphoreSyncFDExportInfo(SharedFenceVkSemaphoreSyncFDExportInfo::Init&& init)
  : … { … }

operator const WGPUSharedFenceVkSemaphoreSyncFDExportInfo &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceVkSemaphoreZirconHandleDescriptor implementation
SharedFenceVkSemaphoreZirconHandleDescriptor::SharedFenceVkSemaphoreZirconHandleDescriptor()
  : … { … }
struct SharedFenceVkSemaphoreZirconHandleDescriptor::Init { … };
SharedFenceVkSemaphoreZirconHandleDescriptor::SharedFenceVkSemaphoreZirconHandleDescriptor(SharedFenceVkSemaphoreZirconHandleDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedFenceVkSemaphoreZirconHandleDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedFenceVkSemaphoreZirconHandleExportInfo implementation
SharedFenceVkSemaphoreZirconHandleExportInfo::SharedFenceVkSemaphoreZirconHandleExportInfo()
  : … { … }
struct SharedFenceVkSemaphoreZirconHandleExportInfo::Init { … };
SharedFenceVkSemaphoreZirconHandleExportInfo::SharedFenceVkSemaphoreZirconHandleExportInfo(SharedFenceVkSemaphoreZirconHandleExportInfo::Init&& init)
  : … { … }

operator const WGPUSharedFenceVkSemaphoreZirconHandleExportInfo &()

static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryD3DSwapchainBeginState implementation
SharedTextureMemoryD3DSwapchainBeginState::SharedTextureMemoryD3DSwapchainBeginState()
  : … { … }
struct SharedTextureMemoryD3DSwapchainBeginState::Init { … };
SharedTextureMemoryD3DSwapchainBeginState::SharedTextureMemoryD3DSwapchainBeginState(SharedTextureMemoryD3DSwapchainBeginState::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryD3DSwapchainBeginState &()

static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryDXGISharedHandleDescriptor implementation
SharedTextureMemoryDXGISharedHandleDescriptor::SharedTextureMemoryDXGISharedHandleDescriptor()
  : … { … }
struct SharedTextureMemoryDXGISharedHandleDescriptor::Init { … };
SharedTextureMemoryDXGISharedHandleDescriptor::SharedTextureMemoryDXGISharedHandleDescriptor(SharedTextureMemoryDXGISharedHandleDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryDXGISharedHandleDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryEGLImageDescriptor implementation
SharedTextureMemoryEGLImageDescriptor::SharedTextureMemoryEGLImageDescriptor()
  : … { … }
struct SharedTextureMemoryEGLImageDescriptor::Init { … };
SharedTextureMemoryEGLImageDescriptor::SharedTextureMemoryEGLImageDescriptor(SharedTextureMemoryEGLImageDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryEGLImageDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryIOSurfaceDescriptor implementation
SharedTextureMemoryIOSurfaceDescriptor::SharedTextureMemoryIOSurfaceDescriptor()
  : … { … }
struct SharedTextureMemoryIOSurfaceDescriptor::Init { … };
SharedTextureMemoryIOSurfaceDescriptor::SharedTextureMemoryIOSurfaceDescriptor(SharedTextureMemoryIOSurfaceDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryIOSurfaceDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryAHardwareBufferDescriptor implementation
SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBufferDescriptor()
  : … { … }
struct SharedTextureMemoryAHardwareBufferDescriptor::Init { … };
SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBufferDescriptor(SharedTextureMemoryAHardwareBufferDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryAHardwareBufferDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryBeginAccessDescriptor implementation

operator const WGPUSharedTextureMemoryBeginAccessDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryDescriptor implementation

operator const WGPUSharedTextureMemoryDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryDmaBufPlane implementation

operator const WGPUSharedTextureMemoryDmaBufPlane &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryEndAccessState implementation
SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState() = default;
SharedTextureMemoryEndAccessState::~SharedTextureMemoryEndAccessState() { … }

SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState(SharedTextureMemoryEndAccessState&& rhs)
    : … { … }

SharedTextureMemoryEndAccessState& SharedTextureMemoryEndAccessState::operator=(SharedTextureMemoryEndAccessState&& rhs) { … }

void SharedTextureMemoryEndAccessState::FreeMembers() { … }

// static
void SharedTextureMemoryEndAccessState::Reset(SharedTextureMemoryEndAccessState& value) { … }

operator const WGPUSharedTextureMemoryEndAccessState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryOpaqueFDDescriptor implementation
SharedTextureMemoryOpaqueFDDescriptor::SharedTextureMemoryOpaqueFDDescriptor()
  : … { … }
struct SharedTextureMemoryOpaqueFDDescriptor::Init { … };
SharedTextureMemoryOpaqueFDDescriptor::SharedTextureMemoryOpaqueFDDescriptor(SharedTextureMemoryOpaqueFDDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryOpaqueFDDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryVkDedicatedAllocationDescriptor implementation
SharedTextureMemoryVkDedicatedAllocationDescriptor::SharedTextureMemoryVkDedicatedAllocationDescriptor()
  : … { … }
struct SharedTextureMemoryVkDedicatedAllocationDescriptor::Init { … };
SharedTextureMemoryVkDedicatedAllocationDescriptor::SharedTextureMemoryVkDedicatedAllocationDescriptor(SharedTextureMemoryVkDedicatedAllocationDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryVkImageLayoutBeginState implementation
SharedTextureMemoryVkImageLayoutBeginState::SharedTextureMemoryVkImageLayoutBeginState()
  : … { … }
struct SharedTextureMemoryVkImageLayoutBeginState::Init { … };
SharedTextureMemoryVkImageLayoutBeginState::SharedTextureMemoryVkImageLayoutBeginState(SharedTextureMemoryVkImageLayoutBeginState::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryVkImageLayoutBeginState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryVkImageLayoutEndState implementation
SharedTextureMemoryVkImageLayoutEndState::SharedTextureMemoryVkImageLayoutEndState()
  : … { … }
struct SharedTextureMemoryVkImageLayoutEndState::Init { … };
SharedTextureMemoryVkImageLayoutEndState::SharedTextureMemoryVkImageLayoutEndState(SharedTextureMemoryVkImageLayoutEndState::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryVkImageLayoutEndState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryZirconHandleDescriptor implementation
SharedTextureMemoryZirconHandleDescriptor::SharedTextureMemoryZirconHandleDescriptor()
  : … { … }
struct SharedTextureMemoryZirconHandleDescriptor::Init { … };
SharedTextureMemoryZirconHandleDescriptor::SharedTextureMemoryZirconHandleDescriptor(SharedTextureMemoryZirconHandleDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryZirconHandleDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// StaticSamplerBindingLayout implementation
StaticSamplerBindingLayout::StaticSamplerBindingLayout()
  : … { … }
struct StaticSamplerBindingLayout::Init { … };
StaticSamplerBindingLayout::StaticSamplerBindingLayout(StaticSamplerBindingLayout::Init&& init)
  : … { … }

operator const WGPUStaticSamplerBindingLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// StencilFaceState implementation

operator const WGPUStencilFaceState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// StorageTextureBindingLayout implementation

operator const WGPUStorageTextureBindingLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// StringView implementation

operator const WGPUStringView &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceCapabilities implementation
SurfaceCapabilities::SurfaceCapabilities() = default;
SurfaceCapabilities::~SurfaceCapabilities() { … }

SurfaceCapabilities::SurfaceCapabilities(SurfaceCapabilities&& rhs)
    : … { … }

SurfaceCapabilities& SurfaceCapabilities::operator=(SurfaceCapabilities&& rhs) { … }

void SurfaceCapabilities::FreeMembers() { … }

// static
void SurfaceCapabilities::Reset(SurfaceCapabilities& value) { … }

operator const WGPUSurfaceCapabilities &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceConfiguration implementation

operator const WGPUSurfaceConfiguration &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptor implementation

operator const WGPUSurfaceDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromAndroidNativeWindow implementation
SurfaceDescriptorFromAndroidNativeWindow::SurfaceDescriptorFromAndroidNativeWindow()
  : … { … }
struct SurfaceDescriptorFromAndroidNativeWindow::Init { … };
SurfaceDescriptorFromAndroidNativeWindow::SurfaceDescriptorFromAndroidNativeWindow(SurfaceDescriptorFromAndroidNativeWindow::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromAndroidNativeWindow &()

static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromCanvasHTMLSelector implementation
SurfaceDescriptorFromCanvasHTMLSelector::SurfaceDescriptorFromCanvasHTMLSelector()
  : … { … }
struct SurfaceDescriptorFromCanvasHTMLSelector::Init { … };
SurfaceDescriptorFromCanvasHTMLSelector::SurfaceDescriptorFromCanvasHTMLSelector(SurfaceDescriptorFromCanvasHTMLSelector::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromCanvasHTMLSelector &()

static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromMetalLayer implementation
SurfaceDescriptorFromMetalLayer::SurfaceDescriptorFromMetalLayer()
  : … { … }
struct SurfaceDescriptorFromMetalLayer::Init { … };
SurfaceDescriptorFromMetalLayer::SurfaceDescriptorFromMetalLayer(SurfaceDescriptorFromMetalLayer::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromMetalLayer &()

static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromWaylandSurface implementation
SurfaceDescriptorFromWaylandSurface::SurfaceDescriptorFromWaylandSurface()
  : … { … }
struct SurfaceDescriptorFromWaylandSurface::Init { … };
SurfaceDescriptorFromWaylandSurface::SurfaceDescriptorFromWaylandSurface(SurfaceDescriptorFromWaylandSurface::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromWaylandSurface &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromWindowsHWND implementation
SurfaceDescriptorFromWindowsHWND::SurfaceDescriptorFromWindowsHWND()
  : … { … }
struct SurfaceDescriptorFromWindowsHWND::Init { … };
SurfaceDescriptorFromWindowsHWND::SurfaceDescriptorFromWindowsHWND(SurfaceDescriptorFromWindowsHWND::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromWindowsHWND &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromWindowsCoreWindow implementation
SurfaceDescriptorFromWindowsCoreWindow::SurfaceDescriptorFromWindowsCoreWindow()
  : … { … }
struct SurfaceDescriptorFromWindowsCoreWindow::Init { … };
SurfaceDescriptorFromWindowsCoreWindow::SurfaceDescriptorFromWindowsCoreWindow(SurfaceDescriptorFromWindowsCoreWindow::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromWindowsCoreWindow &()

static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromWindowsSwapChainPanel implementation
SurfaceDescriptorFromWindowsSwapChainPanel::SurfaceDescriptorFromWindowsSwapChainPanel()
  : … { … }
struct SurfaceDescriptorFromWindowsSwapChainPanel::Init { … };
SurfaceDescriptorFromWindowsSwapChainPanel::SurfaceDescriptorFromWindowsSwapChainPanel(SurfaceDescriptorFromWindowsSwapChainPanel::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromWindowsSwapChainPanel &()

static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromXcbWindow implementation
SurfaceDescriptorFromXcbWindow::SurfaceDescriptorFromXcbWindow()
  : … { … }
struct SurfaceDescriptorFromXcbWindow::Init { … };
SurfaceDescriptorFromXcbWindow::SurfaceDescriptorFromXcbWindow(SurfaceDescriptorFromXcbWindow::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromXcbWindow &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceDescriptorFromXlibWindow implementation
SurfaceDescriptorFromXlibWindow::SurfaceDescriptorFromXlibWindow()
  : … { … }
struct SurfaceDescriptorFromXlibWindow::Init { … };
SurfaceDescriptorFromXlibWindow::SurfaceDescriptorFromXlibWindow(SurfaceDescriptorFromXlibWindow::Init&& init)
  : … { … }

operator const WGPUSurfaceDescriptorFromXlibWindow &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SurfaceTexture implementation

operator const WGPUSurfaceTexture &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SwapChainDescriptor implementation

operator const WGPUSwapChainDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// TextureBindingLayout implementation

operator const WGPUTextureBindingLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// TextureBindingViewDimensionDescriptor implementation
TextureBindingViewDimensionDescriptor::TextureBindingViewDimensionDescriptor()
  : … { … }
struct TextureBindingViewDimensionDescriptor::Init { … };
TextureBindingViewDimensionDescriptor::TextureBindingViewDimensionDescriptor(TextureBindingViewDimensionDescriptor::Init&& init)
  : … { … }

operator const WGPUTextureBindingViewDimensionDescriptor &()

static_assert …;
static_assert …;
static_assert …;

// TextureDataLayout implementation

operator const WGPUTextureDataLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// TextureViewDescriptor implementation

operator const WGPUTextureViewDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// UncapturedErrorCallbackInfo implementation

operator const WGPUUncapturedErrorCallbackInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// VertexAttribute implementation

operator const WGPUVertexAttribute &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// YCbCrVkDescriptor implementation
YCbCrVkDescriptor::YCbCrVkDescriptor()
  : … { … }
struct YCbCrVkDescriptor::Init { … };
YCbCrVkDescriptor::YCbCrVkDescriptor(YCbCrVkDescriptor::Init&& init)
  : … { … }

operator const WGPUYCbCrVkDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// AHardwareBufferProperties implementation

operator const WGPUAHardwareBufferProperties &()

static_assert …;
static_assert …;
static_assert …;

// AdapterPropertiesMemoryHeaps implementation
AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps()
  : … { … }
struct AdapterPropertiesMemoryHeaps::Init { … };
AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps::Init&& init)
  : … { … }
AdapterPropertiesMemoryHeaps::~AdapterPropertiesMemoryHeaps() { … }

AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps&& rhs)
    : … { … }

AdapterPropertiesMemoryHeaps& AdapterPropertiesMemoryHeaps::operator=(AdapterPropertiesMemoryHeaps&& rhs) { … }

void AdapterPropertiesMemoryHeaps::FreeMembers() { … }

// static
void AdapterPropertiesMemoryHeaps::Reset(AdapterPropertiesMemoryHeaps& value) { … }

operator const WGPUAdapterPropertiesMemoryHeaps &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BindGroupDescriptor implementation

operator const WGPUBindGroupDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BindGroupLayoutEntry implementation

operator const WGPUBindGroupLayoutEntry &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BlendState implementation

operator const WGPUBlendState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// CompilationInfo implementation

operator const WGPUCompilationInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ComputePassDescriptor implementation

operator const WGPUComputePassDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DepthStencilState implementation

operator const WGPUDepthStencilState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DrmFormatCapabilities implementation
DrmFormatCapabilities::DrmFormatCapabilities()
  : … { … }
struct DrmFormatCapabilities::Init { … };
DrmFormatCapabilities::DrmFormatCapabilities(DrmFormatCapabilities::Init&& init)
  : … { … }
DrmFormatCapabilities::~DrmFormatCapabilities() { … }

DrmFormatCapabilities::DrmFormatCapabilities(DrmFormatCapabilities&& rhs)
    : … { … }

DrmFormatCapabilities& DrmFormatCapabilities::operator=(DrmFormatCapabilities&& rhs) { … }

void DrmFormatCapabilities::FreeMembers() { … }

// static
void DrmFormatCapabilities::Reset(DrmFormatCapabilities& value) { … }

operator const WGPUDrmFormatCapabilities &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ExternalTextureDescriptor implementation

operator const WGPUExternalTextureDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// FutureWaitInfo implementation

operator const WGPUFutureWaitInfo &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ImageCopyBuffer implementation

operator const WGPUImageCopyBuffer &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ImageCopyExternalTexture implementation

operator const WGPUImageCopyExternalTexture &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ImageCopyTexture implementation

operator const WGPUImageCopyTexture &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// InstanceDescriptor implementation

operator const WGPUInstanceDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// PipelineLayoutPixelLocalStorage implementation
PipelineLayoutPixelLocalStorage::PipelineLayoutPixelLocalStorage()
  : … { … }
struct PipelineLayoutPixelLocalStorage::Init { … };
PipelineLayoutPixelLocalStorage::PipelineLayoutPixelLocalStorage(PipelineLayoutPixelLocalStorage::Init&& init)
  : … { … }

operator const WGPUPipelineLayoutPixelLocalStorage &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ProgrammableStageDescriptor implementation

operator const WGPUProgrammableStageDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassColorAttachment implementation

operator const WGPURenderPassColorAttachment &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassStorageAttachment implementation

operator const WGPURenderPassStorageAttachment &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RequiredLimits implementation

operator const WGPURequiredLimits &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryAHardwareBufferProperties implementation
SharedTextureMemoryAHardwareBufferProperties::SharedTextureMemoryAHardwareBufferProperties()
  : … { … }
struct SharedTextureMemoryAHardwareBufferProperties::Init { … };
SharedTextureMemoryAHardwareBufferProperties::SharedTextureMemoryAHardwareBufferProperties(SharedTextureMemoryAHardwareBufferProperties::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryAHardwareBufferProperties &()

static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryDmaBufDescriptor implementation
SharedTextureMemoryDmaBufDescriptor::SharedTextureMemoryDmaBufDescriptor()
  : … { … }
struct SharedTextureMemoryDmaBufDescriptor::Init { … };
SharedTextureMemoryDmaBufDescriptor::SharedTextureMemoryDmaBufDescriptor(SharedTextureMemoryDmaBufDescriptor::Init&& init)
  : … { … }

operator const WGPUSharedTextureMemoryDmaBufDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SharedTextureMemoryProperties implementation

operator const WGPUSharedTextureMemoryProperties &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// SupportedLimits implementation

operator const WGPUSupportedLimits &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;

// TextureDescriptor implementation

operator const WGPUTextureDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// VertexBufferLayout implementation

operator const WGPUVertexBufferLayout &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// BindGroupLayoutDescriptor implementation

operator const WGPUBindGroupLayoutDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ColorTargetState implementation

operator const WGPUColorTargetState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// ComputePipelineDescriptor implementation

operator const WGPUComputePipelineDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassDescriptor implementation

operator const WGPURenderPassDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPassPixelLocalStorage implementation
RenderPassPixelLocalStorage::RenderPassPixelLocalStorage()
  : … { … }
struct RenderPassPixelLocalStorage::Init { … };
RenderPassPixelLocalStorage::RenderPassPixelLocalStorage(RenderPassPixelLocalStorage::Init&& init)
  : … { … }

operator const WGPURenderPassPixelLocalStorage &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// VertexState implementation

operator const WGPUVertexState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// FragmentState implementation

operator const WGPUFragmentState &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// RenderPipelineDescriptor implementation

operator const WGPURenderPipelineDescriptor &()

static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;
static_assert …;

// DeviceDescriptor implementation

operator const WGPUDeviceDescriptor &()

DeviceDescriptor::DeviceDescriptor() : … { … }

struct DeviceDescriptor::Init { … };

DeviceDescriptor::DeviceDescriptor(DeviceDescriptor::Init&& init) : … { … }

static_assert …;
static_assert …;

template <typename F, typename T, typename Cb, typename>
void DeviceDescriptor::SetDeviceLostCallback(CallbackMode callbackMode, F callback, T userdata) { … }

template <typename L, typename Cb, typename>
void DeviceDescriptor::SetDeviceLostCallback(CallbackMode callbackMode, L callback) { … }

template <typename F, typename T, typename Cb, typename>
void DeviceDescriptor::SetUncapturedErrorCallback(F callback, T userdata) { … }

template <typename L, typename Cb, typename>
void DeviceDescriptor::SetUncapturedErrorCallback(L callback) { … }

#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic pop
#endif

// Adapter implementation

Device Adapter::CreateDevice(DeviceDescriptor const * descriptor) const { … }
size_t Adapter::EnumerateFeatures(FeatureName * features) const { … }
ConvertibleStatus Adapter::GetFormatCapabilities(TextureFormat format, FormatCapabilities * capabilities) const { … }
ConvertibleStatus Adapter::GetInfo(AdapterInfo * info) const { … }
Instance Adapter::GetInstance() const { … }
ConvertibleStatus Adapter::GetLimits(SupportedLimits * limits) const { … }
ConvertibleStatus Adapter::GetProperties(AdapterProperties * properties) const { … }
Bool Adapter::HasFeature(FeatureName feature) const { … }
void Adapter::RequestDevice(DeviceDescriptor const * descriptor, RequestDeviceCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Adapter::RequestDevice(DeviceDescriptor const * options, CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Adapter::RequestDevice(DeviceDescriptor const * options, CallbackMode callbackMode, L callback) const { … }
Future Adapter::RequestDevice(DeviceDescriptor const * options, RequestDeviceCallbackInfo callbackInfo) const { … }


void Adapter::WGPUAddRef(WGPUAdapter handle) { … }
void Adapter::WGPURelease(WGPUAdapter handle) { … }
static_assert …;
static_assert …;

// BindGroup implementation

void BindGroup::SetLabel(char const * label) const { … }
void BindGroup::SetLabel(NullableStringView label) const { … }


void BindGroup::WGPUAddRef(WGPUBindGroup handle) { … }
void BindGroup::WGPURelease(WGPUBindGroup handle) { … }
static_assert …;
static_assert …;

// BindGroupLayout implementation

void BindGroupLayout::SetLabel(char const * label) const { … }
void BindGroupLayout::SetLabel(NullableStringView label) const { … }


void BindGroupLayout::WGPUAddRef(WGPUBindGroupLayout handle) { … }
void BindGroupLayout::WGPURelease(WGPUBindGroupLayout handle) { … }
static_assert …;
static_assert …;

// Buffer implementation

void Buffer::Destroy() const { … }
void const * Buffer::GetConstMappedRange(size_t offset, size_t size) const { … }
BufferMapState Buffer::GetMapState() const { … }
void * Buffer::GetMappedRange(size_t offset, size_t size) const { … }
uint64_t Buffer::GetSize() const { … }
BufferUsage Buffer::GetUsage() const { … }
void Buffer::MapAsync(MapMode mode, size_t offset, size_t size, BufferMapCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode, L callback) const { … }
Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, BufferMapCallbackInfo callbackInfo) const { … }
void Buffer::SetLabel(char const * label) const { … }
void Buffer::SetLabel(NullableStringView label) const { … }
void Buffer::Unmap() const { … }


void Buffer::WGPUAddRef(WGPUBuffer handle) { … }
void Buffer::WGPURelease(WGPUBuffer handle) { … }
static_assert …;
static_assert …;

// CommandBuffer implementation

void CommandBuffer::SetLabel(char const * label) const { … }
void CommandBuffer::SetLabel(NullableStringView label) const { … }


void CommandBuffer::WGPUAddRef(WGPUCommandBuffer handle) { … }
void CommandBuffer::WGPURelease(WGPUCommandBuffer handle) { … }
static_assert …;
static_assert …;

// CommandEncoder implementation

ComputePassEncoder CommandEncoder::BeginComputePass(ComputePassDescriptor const * descriptor) const { … }
RenderPassEncoder CommandEncoder::BeginRenderPass(RenderPassDescriptor const * descriptor) const { … }
void CommandEncoder::ClearBuffer(Buffer const& buffer, uint64_t offset, uint64_t size) const { … }
void CommandEncoder::CopyBufferToBuffer(Buffer const& source, uint64_t sourceOffset, Buffer const& destination, uint64_t destinationOffset, uint64_t size) const { … }
void CommandEncoder::CopyBufferToTexture(ImageCopyBuffer const * source, ImageCopyTexture const * destination, Extent3D const * copySize) const { … }
void CommandEncoder::CopyTextureToBuffer(ImageCopyTexture const * source, ImageCopyBuffer const * destination, Extent3D const * copySize) const { … }
void CommandEncoder::CopyTextureToTexture(ImageCopyTexture const * source, ImageCopyTexture const * destination, Extent3D const * copySize) const { … }
CommandBuffer CommandEncoder::Finish(CommandBufferDescriptor const * descriptor) const { … }
void CommandEncoder::InjectValidationError(char const * message) const { … }
void CommandEncoder::InjectValidationError(StringView message) const { … }
void CommandEncoder::InsertDebugMarker(char const * markerLabel) const { … }
void CommandEncoder::InsertDebugMarker(StringView markerLabel) const { … }
void CommandEncoder::PopDebugGroup() const { … }
void CommandEncoder::PushDebugGroup(char const * groupLabel) const { … }
void CommandEncoder::PushDebugGroup(StringView groupLabel) const { … }
void CommandEncoder::ResolveQuerySet(QuerySet const& querySet, uint32_t firstQuery, uint32_t queryCount, Buffer const& destination, uint64_t destinationOffset) const { … }
void CommandEncoder::SetLabel(char const * label) const { … }
void CommandEncoder::SetLabel(NullableStringView label) const { … }
void CommandEncoder::WriteBuffer(Buffer const& buffer, uint64_t bufferOffset, uint8_t const * data, uint64_t size) const { … }
void CommandEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const { … }


void CommandEncoder::WGPUAddRef(WGPUCommandEncoder handle) { … }
void CommandEncoder::WGPURelease(WGPUCommandEncoder handle) { … }
static_assert …;
static_assert …;

// ComputePassEncoder implementation

void ComputePassEncoder::DispatchWorkgroups(uint32_t workgroupCountX, uint32_t workgroupCountY, uint32_t workgroupCountZ) const { … }
void ComputePassEncoder::DispatchWorkgroupsIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const { … }
void ComputePassEncoder::End() const { … }
void ComputePassEncoder::InsertDebugMarker(char const * markerLabel) const { … }
void ComputePassEncoder::InsertDebugMarker(StringView markerLabel) const { … }
void ComputePassEncoder::PopDebugGroup() const { … }
void ComputePassEncoder::PushDebugGroup(char const * groupLabel) const { … }
void ComputePassEncoder::PushDebugGroup(StringView groupLabel) const { … }
void ComputePassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const { … }
void ComputePassEncoder::SetLabel(char const * label) const { … }
void ComputePassEncoder::SetLabel(NullableStringView label) const { … }
void ComputePassEncoder::SetPipeline(ComputePipeline const& pipeline) const { … }
void ComputePassEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const { … }


void ComputePassEncoder::WGPUAddRef(WGPUComputePassEncoder handle) { … }
void ComputePassEncoder::WGPURelease(WGPUComputePassEncoder handle) { … }
static_assert …;
static_assert …;

// ComputePipeline implementation

BindGroupLayout ComputePipeline::GetBindGroupLayout(uint32_t groupIndex) const { … }
void ComputePipeline::SetLabel(char const * label) const { … }
void ComputePipeline::SetLabel(NullableStringView label) const { … }


void ComputePipeline::WGPUAddRef(WGPUComputePipeline handle) { … }
void ComputePipeline::WGPURelease(WGPUComputePipeline handle) { … }
static_assert …;
static_assert …;

// Device implementation

BindGroup Device::CreateBindGroup(BindGroupDescriptor const * descriptor) const { … }
BindGroupLayout Device::CreateBindGroupLayout(BindGroupLayoutDescriptor const * descriptor) const { … }
Buffer Device::CreateBuffer(BufferDescriptor const * descriptor) const { … }
CommandEncoder Device::CreateCommandEncoder(CommandEncoderDescriptor const * descriptor) const { … }
ComputePipeline Device::CreateComputePipeline(ComputePipelineDescriptor const * descriptor) const { … }
void Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CreateComputePipelineAsyncCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, L callback) const { … }
Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CreateComputePipelineAsyncCallbackInfo callbackInfo) const { … }
Buffer Device::CreateErrorBuffer(BufferDescriptor const * descriptor) const { … }
ExternalTexture Device::CreateErrorExternalTexture() const { … }
ShaderModule Device::CreateErrorShaderModule(ShaderModuleDescriptor const * descriptor, char const * errorMessage) const { … }
ShaderModule Device::CreateErrorShaderModule(ShaderModuleDescriptor const * descriptor, StringView errorMessage) const { … }
Texture Device::CreateErrorTexture(TextureDescriptor const * descriptor) const { … }
ExternalTexture Device::CreateExternalTexture(ExternalTextureDescriptor const * externalTextureDescriptor) const { … }
PipelineLayout Device::CreatePipelineLayout(PipelineLayoutDescriptor const * descriptor) const { … }
QuerySet Device::CreateQuerySet(QuerySetDescriptor const * descriptor) const { … }
RenderBundleEncoder Device::CreateRenderBundleEncoder(RenderBundleEncoderDescriptor const * descriptor) const { … }
RenderPipeline Device::CreateRenderPipeline(RenderPipelineDescriptor const * descriptor) const { … }
void Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CreateRenderPipelineAsyncCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode, L callback) const { … }
Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CreateRenderPipelineAsyncCallbackInfo callbackInfo) const { … }
Sampler Device::CreateSampler(SamplerDescriptor const * descriptor) const { … }
ShaderModule Device::CreateShaderModule(ShaderModuleDescriptor const * descriptor) const { … }
SwapChain Device::CreateSwapChain(Surface const& surface, SwapChainDescriptor const * descriptor) const { … }
Texture Device::CreateTexture(TextureDescriptor const * descriptor) const { … }
void Device::Destroy() const { … }
size_t Device::EnumerateFeatures(FeatureName * features) const { … }
void Device::ForceLoss(DeviceLostReason type, char const * message) const { … }
void Device::ForceLoss(DeviceLostReason type, StringView message) const { … }
ConvertibleStatus Device::GetAHardwareBufferProperties(void * handle, AHardwareBufferProperties * properties) const { … }
Adapter Device::GetAdapter() const { … }
ConvertibleStatus Device::GetLimits(SupportedLimits * limits) const { … }
Queue Device::GetQueue() const { … }
TextureUsage Device::GetSupportedSurfaceUsage(Surface const& surface) const { … }
Bool Device::HasFeature(FeatureName feature) const { … }
SharedBufferMemory Device::ImportSharedBufferMemory(SharedBufferMemoryDescriptor const * descriptor) const { … }
SharedFence Device::ImportSharedFence(SharedFenceDescriptor const * descriptor) const { … }
SharedTextureMemory Device::ImportSharedTextureMemory(SharedTextureMemoryDescriptor const * descriptor) const { … }
void Device::InjectError(ErrorType type, char const * message) const { … }
void Device::InjectError(ErrorType type, StringView message) const { … }
void Device::PopErrorScope(ErrorCallback oldCallback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Device::PopErrorScope(CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Device::PopErrorScope(CallbackMode callbackMode, L callback) const { … }
Future Device::PopErrorScope(PopErrorScopeCallbackInfo callbackInfo) const { … }
void Device::PushErrorScope(ErrorFilter filter) const { … }
void Device::SetDeviceLostCallback(DeviceLostCallback callback, void * userdata) const { … }
void Device::SetLabel(char const * label) const { … }
void Device::SetLabel(NullableStringView label) const { … }
void Device::SetLoggingCallback(LoggingCallback callback, void * userdata) const { … }
void Device::SetUncapturedErrorCallback(ErrorCallback callback, void * userdata) const { … }
void Device::Tick() const { … }
void Device::ValidateTextureDescriptor(TextureDescriptor const * descriptor) const { … }


void Device::WGPUAddRef(WGPUDevice handle) { … }
void Device::WGPURelease(WGPUDevice handle) { … }
static_assert …;
static_assert …;

// ExternalTexture implementation

void ExternalTexture::Destroy() const { … }
void ExternalTexture::Expire() const { … }
void ExternalTexture::Refresh() const { … }
void ExternalTexture::SetLabel(char const * label) const { … }
void ExternalTexture::SetLabel(NullableStringView label) const { … }


void ExternalTexture::WGPUAddRef(WGPUExternalTexture handle) { … }
void ExternalTexture::WGPURelease(WGPUExternalTexture handle) { … }
static_assert …;
static_assert …;

// Instance implementation

Surface Instance::CreateSurface(SurfaceDescriptor const * descriptor) const { … }
size_t Instance::EnumerateWGSLLanguageFeatures(WGSLFeatureName * features) const { … }
Bool Instance::HasWGSLLanguageFeature(WGSLFeatureName feature) const { … }
void Instance::ProcessEvents() const { … }
void Instance::RequestAdapter(RequestAdapterOptions const * options, RequestAdapterCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode, L callback) const { … }
Future Instance::RequestAdapter(RequestAdapterOptions const * options, RequestAdapterCallbackInfo callbackInfo) const { … }
WaitStatus Instance::WaitAny(size_t futureCount, FutureWaitInfo * futures, uint64_t timeoutNS) const { … }

WaitStatus Instance::WaitAny(Future f, uint64_t timeout) { … }

void Instance::WGPUAddRef(WGPUInstance handle) { … }
void Instance::WGPURelease(WGPUInstance handle) { … }
static_assert …;
static_assert …;

// PipelineLayout implementation

void PipelineLayout::SetLabel(char const * label) const { … }
void PipelineLayout::SetLabel(NullableStringView label) const { … }


void PipelineLayout::WGPUAddRef(WGPUPipelineLayout handle) { … }
void PipelineLayout::WGPURelease(WGPUPipelineLayout handle) { … }
static_assert …;
static_assert …;

// QuerySet implementation

void QuerySet::Destroy() const { … }
uint32_t QuerySet::GetCount() const { … }
QueryType QuerySet::GetType() const { … }
void QuerySet::SetLabel(char const * label) const { … }
void QuerySet::SetLabel(NullableStringView label) const { … }


void QuerySet::WGPUAddRef(WGPUQuerySet handle) { … }
void QuerySet::WGPURelease(WGPUQuerySet handle) { … }
static_assert …;
static_assert …;

// Queue implementation

void Queue::CopyExternalTextureForBrowser(ImageCopyExternalTexture const * source, ImageCopyTexture const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const { … }
void Queue::CopyTextureForBrowser(ImageCopyTexture const * source, ImageCopyTexture const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const { … }
void Queue::OnSubmittedWorkDone(QueueWorkDoneCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode, L callback) const { … }
Future Queue::OnSubmittedWorkDone(QueueWorkDoneCallbackInfo callbackInfo) const { … }
void Queue::SetLabel(char const * label) const { … }
void Queue::SetLabel(NullableStringView label) const { … }
void Queue::Submit(size_t commandCount, CommandBuffer const * commands) const { … }
void Queue::WriteBuffer(Buffer const& buffer, uint64_t bufferOffset, void const * data, size_t size) const { … }
void Queue::WriteTexture(ImageCopyTexture const * destination, void const * data, size_t dataSize, TextureDataLayout const * dataLayout, Extent3D const * writeSize) const { … }


void Queue::WGPUAddRef(WGPUQueue handle) { … }
void Queue::WGPURelease(WGPUQueue handle) { … }
static_assert …;
static_assert …;

// RenderBundle implementation

void RenderBundle::SetLabel(char const * label) const { … }
void RenderBundle::SetLabel(NullableStringView label) const { … }


void RenderBundle::WGPUAddRef(WGPURenderBundle handle) { … }
void RenderBundle::WGPURelease(WGPURenderBundle handle) { … }
static_assert …;
static_assert …;

// RenderBundleEncoder implementation

void RenderBundleEncoder::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const { … }
void RenderBundleEncoder::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance) const { … }
void RenderBundleEncoder::DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const { … }
void RenderBundleEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const { … }
RenderBundle RenderBundleEncoder::Finish(RenderBundleDescriptor const * descriptor) const { … }
void RenderBundleEncoder::InsertDebugMarker(char const * markerLabel) const { … }
void RenderBundleEncoder::InsertDebugMarker(StringView markerLabel) const { … }
void RenderBundleEncoder::PopDebugGroup() const { … }
void RenderBundleEncoder::PushDebugGroup(char const * groupLabel) const { … }
void RenderBundleEncoder::PushDebugGroup(StringView groupLabel) const { … }
void RenderBundleEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const { … }
void RenderBundleEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const { … }
void RenderBundleEncoder::SetLabel(char const * label) const { … }
void RenderBundleEncoder::SetLabel(NullableStringView label) const { … }
void RenderBundleEncoder::SetPipeline(RenderPipeline const& pipeline) const { … }
void RenderBundleEncoder::SetVertexBuffer(uint32_t slot, Buffer const& buffer, uint64_t offset, uint64_t size) const { … }


void RenderBundleEncoder::WGPUAddRef(WGPURenderBundleEncoder handle) { … }
void RenderBundleEncoder::WGPURelease(WGPURenderBundleEncoder handle) { … }
static_assert …;
static_assert …;

// RenderPassEncoder implementation

void RenderPassEncoder::BeginOcclusionQuery(uint32_t queryIndex) const { … }
void RenderPassEncoder::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const { … }
void RenderPassEncoder::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance) const { … }
void RenderPassEncoder::DrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const { … }
void RenderPassEncoder::DrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset) const { … }
void RenderPassEncoder::End() const { … }
void RenderPassEncoder::EndOcclusionQuery() const { … }
void RenderPassEncoder::ExecuteBundles(size_t bundleCount, RenderBundle const * bundles) const { … }
void RenderPassEncoder::InsertDebugMarker(char const * markerLabel) const { … }
void RenderPassEncoder::InsertDebugMarker(StringView markerLabel) const { … }
void RenderPassEncoder::MultiDrawIndexedIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer, uint64_t drawCountBufferOffset) const { … }
void RenderPassEncoder::MultiDrawIndirect(Buffer const& indirectBuffer, uint64_t indirectOffset, uint32_t maxDrawCount, Buffer const& drawCountBuffer, uint64_t drawCountBufferOffset) const { … }
void RenderPassEncoder::PixelLocalStorageBarrier() const { … }
void RenderPassEncoder::PopDebugGroup() const { … }
void RenderPassEncoder::PushDebugGroup(char const * groupLabel) const { … }
void RenderPassEncoder::PushDebugGroup(StringView groupLabel) const { … }
void RenderPassEncoder::SetBindGroup(uint32_t groupIndex, BindGroup const& group, size_t dynamicOffsetCount, uint32_t const * dynamicOffsets) const { … }
void RenderPassEncoder::SetBlendConstant(Color const * color) const { … }
void RenderPassEncoder::SetIndexBuffer(Buffer const& buffer, IndexFormat format, uint64_t offset, uint64_t size) const { … }
void RenderPassEncoder::SetLabel(char const * label) const { … }
void RenderPassEncoder::SetLabel(NullableStringView label) const { … }
void RenderPassEncoder::SetPipeline(RenderPipeline const& pipeline) const { … }
void RenderPassEncoder::SetScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height) const { … }
void RenderPassEncoder::SetStencilReference(uint32_t reference) const { … }
void RenderPassEncoder::SetVertexBuffer(uint32_t slot, Buffer const& buffer, uint64_t offset, uint64_t size) const { … }
void RenderPassEncoder::SetViewport(float x, float y, float width, float height, float minDepth, float maxDepth) const { … }
void RenderPassEncoder::WriteTimestamp(QuerySet const& querySet, uint32_t queryIndex) const { … }


void RenderPassEncoder::WGPUAddRef(WGPURenderPassEncoder handle) { … }
void RenderPassEncoder::WGPURelease(WGPURenderPassEncoder handle) { … }
static_assert …;
static_assert …;

// RenderPipeline implementation

BindGroupLayout RenderPipeline::GetBindGroupLayout(uint32_t groupIndex) const { … }
void RenderPipeline::SetLabel(char const * label) const { … }
void RenderPipeline::SetLabel(NullableStringView label) const { … }


void RenderPipeline::WGPUAddRef(WGPURenderPipeline handle) { … }
void RenderPipeline::WGPURelease(WGPURenderPipeline handle) { … }
static_assert …;
static_assert …;

// Sampler implementation

void Sampler::SetLabel(char const * label) const { … }
void Sampler::SetLabel(NullableStringView label) const { … }


void Sampler::WGPUAddRef(WGPUSampler handle) { … }
void Sampler::WGPURelease(WGPUSampler handle) { … }
static_assert …;
static_assert …;

// ShaderModule implementation

void ShaderModule::GetCompilationInfo(CompilationInfoCallback callback, void * userdata) const { … }
template <typename F, typename T,
          typename Cb,
          typename>
Future ShaderModule::GetCompilationInfo(CallbackMode callbackMode, F callback, T userdata) const { … }
template <typename L,
          typename Cb,
          typename>
Future ShaderModule::GetCompilationInfo(CallbackMode callbackMode, L callback) const { … }
Future ShaderModule::GetCompilationInfo(CompilationInfoCallbackInfo callbackInfo) const { … }
void ShaderModule::SetLabel(char const * label) const { … }
void ShaderModule::SetLabel(NullableStringView label) const { … }


void ShaderModule::WGPUAddRef(WGPUShaderModule handle) { … }
void ShaderModule::WGPURelease(WGPUShaderModule handle) { … }
static_assert …;
static_assert …;

// SharedBufferMemory implementation

ConvertibleStatus SharedBufferMemory::BeginAccess(Buffer const& buffer, SharedBufferMemoryBeginAccessDescriptor const * descriptor) const { … }
Buffer SharedBufferMemory::CreateBuffer(BufferDescriptor const * descriptor) const { … }
ConvertibleStatus SharedBufferMemory::EndAccess(Buffer const& buffer, SharedBufferMemoryEndAccessState * descriptor) const { … }
ConvertibleStatus SharedBufferMemory::GetProperties(SharedBufferMemoryProperties * properties) const { … }
Bool SharedBufferMemory::IsDeviceLost() const { … }
void SharedBufferMemory::SetLabel(char const * label) const { … }
void SharedBufferMemory::SetLabel(NullableStringView label) const { … }


void SharedBufferMemory::WGPUAddRef(WGPUSharedBufferMemory handle) { … }
void SharedBufferMemory::WGPURelease(WGPUSharedBufferMemory handle) { … }
static_assert …;
static_assert …;

// SharedFence implementation

void SharedFence::ExportInfo(SharedFenceExportInfo * info) const { … }


void SharedFence::WGPUAddRef(WGPUSharedFence handle) { … }
void SharedFence::WGPURelease(WGPUSharedFence handle) { … }
static_assert …;
static_assert …;

// SharedTextureMemory implementation

ConvertibleStatus SharedTextureMemory::BeginAccess(Texture const& texture, SharedTextureMemoryBeginAccessDescriptor const * descriptor) const { … }
Texture SharedTextureMemory::CreateTexture(TextureDescriptor const * descriptor) const { … }
ConvertibleStatus SharedTextureMemory::EndAccess(Texture const& texture, SharedTextureMemoryEndAccessState * descriptor) const { … }
ConvertibleStatus SharedTextureMemory::GetProperties(SharedTextureMemoryProperties * properties) const { … }
Bool SharedTextureMemory::IsDeviceLost() const { … }
void SharedTextureMemory::SetLabel(char const * label) const { … }
void SharedTextureMemory::SetLabel(NullableStringView label) const { … }


void SharedTextureMemory::WGPUAddRef(WGPUSharedTextureMemory handle) { … }
void SharedTextureMemory::WGPURelease(WGPUSharedTextureMemory handle) { … }
static_assert …;
static_assert …;

// Surface implementation

void Surface::Configure(SurfaceConfiguration const * config) const { … }
ConvertibleStatus Surface::GetCapabilities(Adapter const& adapter, SurfaceCapabilities * capabilities) const { … }
void Surface::GetCurrentTexture(SurfaceTexture * surfaceTexture) const { … }
TextureFormat Surface::GetPreferredFormat(Adapter const& adapter) const { … }
void Surface::Present() const { … }
void Surface::SetLabel(char const * label) const { … }
void Surface::SetLabel(NullableStringView label) const { … }
void Surface::Unconfigure() const { … }


void Surface::WGPUAddRef(WGPUSurface handle) { … }
void Surface::WGPURelease(WGPUSurface handle) { … }
static_assert …;
static_assert …;

// SwapChain implementation

Texture SwapChain::GetCurrentTexture() const { … }
TextureView SwapChain::GetCurrentTextureView() const { … }
void SwapChain::Present() const { … }


void SwapChain::WGPUAddRef(WGPUSwapChain handle) { … }
void SwapChain::WGPURelease(WGPUSwapChain handle) { … }
static_assert …;
static_assert …;

// Texture implementation

TextureView Texture::CreateErrorView(TextureViewDescriptor const * descriptor) const { … }
TextureView Texture::CreateView(TextureViewDescriptor const * descriptor) const { … }
void Texture::Destroy() const { … }
uint32_t Texture::GetDepthOrArrayLayers() const { … }
TextureDimension Texture::GetDimension() const { … }
TextureFormat Texture::GetFormat() const { … }
uint32_t Texture::GetHeight() const { … }
uint32_t Texture::GetMipLevelCount() const { … }
uint32_t Texture::GetSampleCount() const { … }
TextureUsage Texture::GetUsage() const { … }
uint32_t Texture::GetWidth() const { … }
void Texture::SetLabel(char const * label) const { … }
void Texture::SetLabel(NullableStringView label) const { … }


void Texture::WGPUAddRef(WGPUTexture handle) { … }
void Texture::WGPURelease(WGPUTexture handle) { … }
static_assert …;
static_assert …;

// TextureView implementation

void TextureView::SetLabel(char const * label) const { … }
void TextureView::SetLabel(NullableStringView label) const { … }


void TextureView::WGPUAddRef(WGPUTextureView handle) { … }
void TextureView::WGPURelease(WGPUTextureView handle) { … }
static_assert …;
static_assert …;




// Free Functions
static inline Instance CreateInstance(InstanceDescriptor const * descriptor = nullptr) { … }
static inline Status GetInstanceFeatures(InstanceFeatures * features) { … }
static inline Proc GetProcAddress(Device device, char const * procName) { … }
static inline Proc GetProcAddress(Device device, StringView procName) { … }

}  // namespace wgpu

namespace wgpu {
template<>
struct IsWGPUBitmask<wgpu::BufferUsage> { … };

template<>
struct IsWGPUBitmask<wgpu::ColorWriteMask> { … };

template<>
struct IsWGPUBitmask<wgpu::HeapProperty> { … };

template<>
struct IsWGPUBitmask<wgpu::MapMode> { … };

template<>
struct IsWGPUBitmask<wgpu::ShaderStage> { … };

template<>
struct IsWGPUBitmask<wgpu::TextureUsage> { … };

} // namespace wgpu

namespace std {
// Custom boolean class needs corresponding hash function so that it appears as a transparent bool.
template <>
struct hash<wgpu::Bool> { … };
template <>
struct hash<wgpu::OptionalBool> { … };
}  // namespace std

#endif // WEBGPU_CPP_H_