# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! #
#   This file is generated by webgpu.xs.PL  #
# !!!!!!!   ANY EDIT WILL BE LOST   !!!!!!! #

use v5.30;
use warnings;
use Carp;

package # Hide from PAUSE
    WebGPU::Direct::XS
{
  our $VERSION = '0.16';
  require XSLoader;
  XSLoader::load('WebGPU::Direct', $VERSION);
}

package # Hide from PAUSE
    WebGPU::Direct::Opaque {
}

require WebGPU::Direct::MappedBuffer;
require WebGPU::Direct::Error;

package
	WebGPU::Direct {
  sub createInstance { my $class = shift; WebGPU::Direct::XS::createInstance(@_); }
  sub getInstanceCapabilities { my $class = shift; WebGPU::Direct::XS::getInstanceCapabilities(@_); }
  sub getProcAddress { my $class = shift; WebGPU::Direct::XS::getProcAddress(@_); }
  our @export_all;
  sub AdapterType () { 'WebGPU::Direct::AdapterType' }; push @export_all, 'AdapterType';
  sub AddressMode () { 'WebGPU::Direct::AddressMode' }; push @export_all, 'AddressMode';
  sub BackendType () { 'WebGPU::Direct::BackendType' }; push @export_all, 'BackendType';
  sub BlendFactor () { 'WebGPU::Direct::BlendFactor' }; push @export_all, 'BlendFactor';
  sub BlendOperation () { 'WebGPU::Direct::BlendOperation' }; push @export_all, 'BlendOperation';
  sub BufferBindingType () { 'WebGPU::Direct::BufferBindingType' }; push @export_all, 'BufferBindingType';
  sub BufferMapState () { 'WebGPU::Direct::BufferMapState' }; push @export_all, 'BufferMapState';
  sub BufferUsage () { 'WebGPU::Direct::BufferUsage' }; push @export_all, 'BufferUsage';
  sub CallbackMode () { 'WebGPU::Direct::CallbackMode' }; push @export_all, 'CallbackMode';
  sub ColorWriteMask () { 'WebGPU::Direct::ColorWriteMask' }; push @export_all, 'ColorWriteMask';
  sub CompareFunction () { 'WebGPU::Direct::CompareFunction' }; push @export_all, 'CompareFunction';
  sub CompilationInfoRequestStatus () { 'WebGPU::Direct::CompilationInfoRequestStatus' }; push @export_all, 'CompilationInfoRequestStatus';
  sub CompilationMessageType () { 'WebGPU::Direct::CompilationMessageType' }; push @export_all, 'CompilationMessageType';
  sub CompositeAlphaMode () { 'WebGPU::Direct::CompositeAlphaMode' }; push @export_all, 'CompositeAlphaMode';
  sub CreatePipelineAsyncStatus () { 'WebGPU::Direct::CreatePipelineAsyncStatus' }; push @export_all, 'CreatePipelineAsyncStatus';
  sub CullMode () { 'WebGPU::Direct::CullMode' }; push @export_all, 'CullMode';
  sub DeviceLostReason () { 'WebGPU::Direct::DeviceLostReason' }; push @export_all, 'DeviceLostReason';
  sub ErrorFilter () { 'WebGPU::Direct::ErrorFilter' }; push @export_all, 'ErrorFilter';
  sub ErrorType () { 'WebGPU::Direct::ErrorType' }; push @export_all, 'ErrorType';
  sub FeatureLevel () { 'WebGPU::Direct::FeatureLevel' }; push @export_all, 'FeatureLevel';
  sub FeatureName () { 'WebGPU::Direct::FeatureName' }; push @export_all, 'FeatureName';
  sub FilterMode () { 'WebGPU::Direct::FilterMode' }; push @export_all, 'FilterMode';
  sub FrontFace () { 'WebGPU::Direct::FrontFace' }; push @export_all, 'FrontFace';
  sub IndexFormat () { 'WebGPU::Direct::IndexFormat' }; push @export_all, 'IndexFormat';
  sub LoadOp () { 'WebGPU::Direct::LoadOp' }; push @export_all, 'LoadOp';
  sub MapAsyncStatus () { 'WebGPU::Direct::MapAsyncStatus' }; push @export_all, 'MapAsyncStatus';
  sub MapMode () { 'WebGPU::Direct::MapMode' }; push @export_all, 'MapMode';
  sub MipmapFilterMode () { 'WebGPU::Direct::MipmapFilterMode' }; push @export_all, 'MipmapFilterMode';
  sub OptionalBool () { 'WebGPU::Direct::OptionalBool' }; push @export_all, 'OptionalBool';
  sub PopErrorScopeStatus () { 'WebGPU::Direct::PopErrorScopeStatus' }; push @export_all, 'PopErrorScopeStatus';
  sub PowerPreference () { 'WebGPU::Direct::PowerPreference' }; push @export_all, 'PowerPreference';
  sub PresentMode () { 'WebGPU::Direct::PresentMode' }; push @export_all, 'PresentMode';
  sub PrimitiveTopology () { 'WebGPU::Direct::PrimitiveTopology' }; push @export_all, 'PrimitiveTopology';
  sub QueryType () { 'WebGPU::Direct::QueryType' }; push @export_all, 'QueryType';
  sub QueueWorkDoneStatus () { 'WebGPU::Direct::QueueWorkDoneStatus' }; push @export_all, 'QueueWorkDoneStatus';
  sub RequestAdapterStatus () { 'WebGPU::Direct::RequestAdapterStatus' }; push @export_all, 'RequestAdapterStatus';
  sub RequestDeviceStatus () { 'WebGPU::Direct::RequestDeviceStatus' }; push @export_all, 'RequestDeviceStatus';
  sub SType () { 'WebGPU::Direct::SType' }; push @export_all, 'SType';
  sub SamplerBindingType () { 'WebGPU::Direct::SamplerBindingType' }; push @export_all, 'SamplerBindingType';
  sub ShaderStage () { 'WebGPU::Direct::ShaderStage' }; push @export_all, 'ShaderStage';
  sub Status () { 'WebGPU::Direct::Status' }; push @export_all, 'Status';
  sub StencilOperation () { 'WebGPU::Direct::StencilOperation' }; push @export_all, 'StencilOperation';
  sub StorageTextureAccess () { 'WebGPU::Direct::StorageTextureAccess' }; push @export_all, 'StorageTextureAccess';
  sub StoreOp () { 'WebGPU::Direct::StoreOp' }; push @export_all, 'StoreOp';
  sub SurfaceGetCurrentTextureStatus () { 'WebGPU::Direct::SurfaceGetCurrentTextureStatus' }; push @export_all, 'SurfaceGetCurrentTextureStatus';
  sub TextureAspect () { 'WebGPU::Direct::TextureAspect' }; push @export_all, 'TextureAspect';
  sub TextureDimension () { 'WebGPU::Direct::TextureDimension' }; push @export_all, 'TextureDimension';
  sub TextureFormat () { 'WebGPU::Direct::TextureFormat' }; push @export_all, 'TextureFormat';
  sub TextureSampleType () { 'WebGPU::Direct::TextureSampleType' }; push @export_all, 'TextureSampleType';
  sub TextureUsage () { 'WebGPU::Direct::TextureUsage' }; push @export_all, 'TextureUsage';
  sub TextureViewDimension () { 'WebGPU::Direct::TextureViewDimension' }; push @export_all, 'TextureViewDimension';
  sub VertexFormat () { 'WebGPU::Direct::VertexFormat' }; push @export_all, 'VertexFormat';
  sub VertexStepMode () { 'WebGPU::Direct::VertexStepMode' }; push @export_all, 'VertexStepMode';
  sub WGSLLanguageFeatureName () { 'WebGPU::Direct::WGSLLanguageFeatureName' }; push @export_all, 'WGSLLanguageFeatureName';
  sub WaitStatus () { 'WebGPU::Direct::WaitStatus' }; push @export_all, 'WaitStatus';
  sub AdapterInfo () { Carp::croak if @_>1; 'WebGPU::Direct::AdapterInfo' }
  sub BindGroupDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::BindGroupDescriptor' }
  sub BindGroupEntry () { Carp::croak if @_>1; 'WebGPU::Direct::BindGroupEntry' }
  sub BindGroupLayoutDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::BindGroupLayoutDescriptor' }
  sub BindGroupLayoutEntry () { Carp::croak if @_>1; 'WebGPU::Direct::BindGroupLayoutEntry' }
  sub BlendComponent () { Carp::croak if @_>1; 'WebGPU::Direct::BlendComponent' }
  sub BlendState () { Carp::croak if @_>1; 'WebGPU::Direct::BlendState' }
  sub BufferBindingLayout () { Carp::croak if @_>1; 'WebGPU::Direct::BufferBindingLayout' }
  sub BufferDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::BufferDescriptor' }
  sub BufferMapCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::BufferMapCallbackInfo' }
  sub ChainedStruct () { Carp::croak if @_>1; 'WebGPU::Direct::ChainedStruct' }
  sub ChainedStructOut () { Carp::croak if @_>1; 'WebGPU::Direct::ChainedStructOut' }
  sub Color () { Carp::croak if @_>1; 'WebGPU::Direct::Color' }
  sub ColorTargetState () { Carp::croak if @_>1; 'WebGPU::Direct::ColorTargetState' }
  sub CommandBufferDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::CommandBufferDescriptor' }
  sub CommandEncoderDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::CommandEncoderDescriptor' }
  sub CompilationInfo () { Carp::croak if @_>1; 'WebGPU::Direct::CompilationInfo' }
  sub CompilationInfoCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::CompilationInfoCallbackInfo' }
  sub CompilationMessage () { Carp::croak if @_>1; 'WebGPU::Direct::CompilationMessage' }
  sub ComputePassDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::ComputePassDescriptor' }
  sub ComputePassTimestampWrites () { Carp::croak if @_>1; 'WebGPU::Direct::ComputePassTimestampWrites' }
  sub ComputePipelineDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::ComputePipelineDescriptor' }
  sub ConstantEntry () { Carp::croak if @_>1; 'WebGPU::Direct::ConstantEntry' }
  sub CreateComputePipelineAsyncCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::CreateComputePipelineAsyncCallbackInfo' }
  sub CreateRenderPipelineAsyncCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::CreateRenderPipelineAsyncCallbackInfo' }
  sub DepthStencilState () { Carp::croak if @_>1; 'WebGPU::Direct::DepthStencilState' }
  sub DeviceDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::DeviceDescriptor' }
  sub DeviceLostCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::DeviceLostCallbackInfo' }
  sub Extent3D () { Carp::croak if @_>1; 'WebGPU::Direct::Extent3D' }
  sub FragmentState () { Carp::croak if @_>1; 'WebGPU::Direct::FragmentState' }
  sub Future () { Carp::croak if @_>1; 'WebGPU::Direct::Future' }
  sub FutureWaitInfo () { Carp::croak if @_>1; 'WebGPU::Direct::FutureWaitInfo' }
  sub InstanceCapabilities () { Carp::croak if @_>1; 'WebGPU::Direct::InstanceCapabilities' }
  sub InstanceDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::InstanceDescriptor' }
  sub Limits () { Carp::croak if @_>1; 'WebGPU::Direct::Limits' }
  sub MultisampleState () { Carp::croak if @_>1; 'WebGPU::Direct::MultisampleState' }
  sub Origin3D () { Carp::croak if @_>1; 'WebGPU::Direct::Origin3D' }
  sub PipelineLayoutDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::PipelineLayoutDescriptor' }
  sub PopErrorScopeCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::PopErrorScopeCallbackInfo' }
  sub PrimitiveState () { Carp::croak if @_>1; 'WebGPU::Direct::PrimitiveState' }
  sub ProgrammableStageDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::ProgrammableStageDescriptor' }
  sub QuerySetDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::QuerySetDescriptor' }
  sub QueueDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::QueueDescriptor' }
  sub QueueWorkDoneCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::QueueWorkDoneCallbackInfo' }
  sub RenderBundleDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::RenderBundleDescriptor' }
  sub RenderBundleEncoderDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::RenderBundleEncoderDescriptor' }
  sub RenderPassColorAttachment () { Carp::croak if @_>1; 'WebGPU::Direct::RenderPassColorAttachment' }
  sub RenderPassDepthStencilAttachment () { Carp::croak if @_>1; 'WebGPU::Direct::RenderPassDepthStencilAttachment' }
  sub RenderPassDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::RenderPassDescriptor' }
  sub RenderPassMaxDrawCount () { Carp::croak if @_>1; 'WebGPU::Direct::RenderPassMaxDrawCount' }
  sub RenderPassTimestampWrites () { Carp::croak if @_>1; 'WebGPU::Direct::RenderPassTimestampWrites' }
  sub RenderPipelineDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::RenderPipelineDescriptor' }
  sub RequestAdapterCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::RequestAdapterCallbackInfo' }
  sub RequestAdapterOptions () { Carp::croak if @_>1; 'WebGPU::Direct::RequestAdapterOptions' }
  sub RequestDeviceCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::RequestDeviceCallbackInfo' }
  sub SamplerBindingLayout () { Carp::croak if @_>1; 'WebGPU::Direct::SamplerBindingLayout' }
  sub SamplerDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::SamplerDescriptor' }
  sub ShaderModuleDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::ShaderModuleDescriptor' }
  sub ShaderSourceSPIRV () { Carp::croak if @_>1; 'WebGPU::Direct::ShaderSourceSPIRV' }
  sub ShaderSourceWGSL () { Carp::croak if @_>1; 'WebGPU::Direct::ShaderSourceWGSL' }
  sub StencilFaceState () { Carp::croak if @_>1; 'WebGPU::Direct::StencilFaceState' }
  sub StorageTextureBindingLayout () { Carp::croak if @_>1; 'WebGPU::Direct::StorageTextureBindingLayout' }
  sub StringView () { Carp::croak if @_>1; 'WebGPU::Direct::StringView' }
  sub SupportedFeatures () { Carp::croak if @_>1; 'WebGPU::Direct::SupportedFeatures' }
  sub SupportedWGSLLanguageFeatures () { Carp::croak if @_>1; 'WebGPU::Direct::SupportedWGSLLanguageFeatures' }
  sub SurfaceCapabilities () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceCapabilities' }
  sub SurfaceConfiguration () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceConfiguration' }
  sub SurfaceDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceDescriptor' }
  sub SurfaceSourceAndroidNativeWindow () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceSourceAndroidNativeWindow' }
  sub SurfaceSourceMetalLayer () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceSourceMetalLayer' }
  sub SurfaceSourceWaylandSurface () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceSourceWaylandSurface' }
  sub SurfaceSourceWindowsHWND () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceSourceWindowsHWND' }
  sub SurfaceSourceXCBWindow () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceSourceXCBWindow' }
  sub SurfaceSourceXlibWindow () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceSourceXlibWindow' }
  sub SurfaceTexture () { Carp::croak if @_>1; 'WebGPU::Direct::SurfaceTexture' }
  sub TexelCopyBufferInfo () { Carp::croak if @_>1; 'WebGPU::Direct::TexelCopyBufferInfo' }
  sub TexelCopyBufferLayout () { Carp::croak if @_>1; 'WebGPU::Direct::TexelCopyBufferLayout' }
  sub TexelCopyTextureInfo () { Carp::croak if @_>1; 'WebGPU::Direct::TexelCopyTextureInfo' }
  sub TextureBindingLayout () { Carp::croak if @_>1; 'WebGPU::Direct::TextureBindingLayout' }
  sub TextureDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::TextureDescriptor' }
  sub TextureViewDescriptor () { Carp::croak if @_>1; 'WebGPU::Direct::TextureViewDescriptor' }
  sub UncapturedErrorCallbackInfo () { Carp::croak if @_>1; 'WebGPU::Direct::UncapturedErrorCallbackInfo' }
  sub VertexAttribute () { Carp::croak if @_>1; 'WebGPU::Direct::VertexAttribute' }
  sub VertexBufferLayout () { Carp::croak if @_>1; 'WebGPU::Direct::VertexBufferLayout' }
  sub VertexState () { Carp::croak if @_>1; 'WebGPU::Direct::VertexState' }
  sub newAdapterInfo { my $class = shift; return WebGPU::Direct::AdapterInfo->new(@_); }
  sub newBindGroupDescriptor { my $class = shift; return WebGPU::Direct::BindGroupDescriptor->new(@_); }
  sub newBindGroupEntry { my $class = shift; return WebGPU::Direct::BindGroupEntry->new(@_); }
  sub newBindGroupLayoutDescriptor { my $class = shift; return WebGPU::Direct::BindGroupLayoutDescriptor->new(@_); }
  sub newBindGroupLayoutEntry { my $class = shift; return WebGPU::Direct::BindGroupLayoutEntry->new(@_); }
  sub newBlendComponent { my $class = shift; return WebGPU::Direct::BlendComponent->new(@_); }
  sub newBlendState { my $class = shift; return WebGPU::Direct::BlendState->new(@_); }
  sub newBufferBindingLayout { my $class = shift; return WebGPU::Direct::BufferBindingLayout->new(@_); }
  sub newBufferDescriptor { my $class = shift; return WebGPU::Direct::BufferDescriptor->new(@_); }
  sub newBufferMapCallbackInfo { my $class = shift; return WebGPU::Direct::BufferMapCallbackInfo->new(@_); }
  sub newChainedStruct { my $class = shift; return WebGPU::Direct::ChainedStruct->new(@_); }
  sub newChainedStructOut { my $class = shift; return WebGPU::Direct::ChainedStructOut->new(@_); }
  sub newColor { my $class = shift; return WebGPU::Direct::Color->new(@_); }
  sub newColorTargetState { my $class = shift; return WebGPU::Direct::ColorTargetState->new(@_); }
  sub newCommandBufferDescriptor { my $class = shift; return WebGPU::Direct::CommandBufferDescriptor->new(@_); }
  sub newCommandEncoderDescriptor { my $class = shift; return WebGPU::Direct::CommandEncoderDescriptor->new(@_); }
  sub newCompilationInfo { my $class = shift; return WebGPU::Direct::CompilationInfo->new(@_); }
  sub newCompilationInfoCallbackInfo { my $class = shift; return WebGPU::Direct::CompilationInfoCallbackInfo->new(@_); }
  sub newCompilationMessage { my $class = shift; return WebGPU::Direct::CompilationMessage->new(@_); }
  sub newComputePassDescriptor { my $class = shift; return WebGPU::Direct::ComputePassDescriptor->new(@_); }
  sub newComputePassTimestampWrites { my $class = shift; return WebGPU::Direct::ComputePassTimestampWrites->new(@_); }
  sub newComputePipelineDescriptor { my $class = shift; return WebGPU::Direct::ComputePipelineDescriptor->new(@_); }
  sub newConstantEntry { my $class = shift; return WebGPU::Direct::ConstantEntry->new(@_); }
  sub newCreateComputePipelineAsyncCallbackInfo { my $class = shift; return WebGPU::Direct::CreateComputePipelineAsyncCallbackInfo->new(@_); }
  sub newCreateRenderPipelineAsyncCallbackInfo { my $class = shift; return WebGPU::Direct::CreateRenderPipelineAsyncCallbackInfo->new(@_); }
  sub newDepthStencilState { my $class = shift; return WebGPU::Direct::DepthStencilState->new(@_); }
  sub newDeviceDescriptor { my $class = shift; return WebGPU::Direct::DeviceDescriptor->new(@_); }
  sub newDeviceLostCallbackInfo { my $class = shift; return WebGPU::Direct::DeviceLostCallbackInfo->new(@_); }
  sub newExtent3D { my $class = shift; return WebGPU::Direct::Extent3D->new(@_); }
  sub newFragmentState { my $class = shift; return WebGPU::Direct::FragmentState->new(@_); }
  sub newFuture { my $class = shift; return WebGPU::Direct::Future->new(@_); }
  sub newFutureWaitInfo { my $class = shift; return WebGPU::Direct::FutureWaitInfo->new(@_); }
  sub newInstanceCapabilities { my $class = shift; return WebGPU::Direct::InstanceCapabilities->new(@_); }
  sub newInstanceDescriptor { my $class = shift; return WebGPU::Direct::InstanceDescriptor->new(@_); }
  sub newLimits { my $class = shift; return WebGPU::Direct::Limits->new(@_); }
  sub newMultisampleState { my $class = shift; return WebGPU::Direct::MultisampleState->new(@_); }
  sub newOrigin3D { my $class = shift; return WebGPU::Direct::Origin3D->new(@_); }
  sub newPipelineLayoutDescriptor { my $class = shift; return WebGPU::Direct::PipelineLayoutDescriptor->new(@_); }
  sub newPopErrorScopeCallbackInfo { my $class = shift; return WebGPU::Direct::PopErrorScopeCallbackInfo->new(@_); }
  sub newPrimitiveState { my $class = shift; return WebGPU::Direct::PrimitiveState->new(@_); }
  sub newProgrammableStageDescriptor { my $class = shift; return WebGPU::Direct::ProgrammableStageDescriptor->new(@_); }
  sub newQuerySetDescriptor { my $class = shift; return WebGPU::Direct::QuerySetDescriptor->new(@_); }
  sub newQueueDescriptor { my $class = shift; return WebGPU::Direct::QueueDescriptor->new(@_); }
  sub newQueueWorkDoneCallbackInfo { my $class = shift; return WebGPU::Direct::QueueWorkDoneCallbackInfo->new(@_); }
  sub newRenderBundleDescriptor { my $class = shift; return WebGPU::Direct::RenderBundleDescriptor->new(@_); }
  sub newRenderBundleEncoderDescriptor { my $class = shift; return WebGPU::Direct::RenderBundleEncoderDescriptor->new(@_); }
  sub newRenderPassColorAttachment { my $class = shift; return WebGPU::Direct::RenderPassColorAttachment->new(@_); }
  sub newRenderPassDepthStencilAttachment { my $class = shift; return WebGPU::Direct::RenderPassDepthStencilAttachment->new(@_); }
  sub newRenderPassDescriptor { my $class = shift; return WebGPU::Direct::RenderPassDescriptor->new(@_); }
  sub newRenderPassMaxDrawCount { my $class = shift; return WebGPU::Direct::RenderPassMaxDrawCount->new(@_); }
  sub newRenderPassTimestampWrites { my $class = shift; return WebGPU::Direct::RenderPassTimestampWrites->new(@_); }
  sub newRenderPipelineDescriptor { my $class = shift; return WebGPU::Direct::RenderPipelineDescriptor->new(@_); }
  sub newRequestAdapterCallbackInfo { my $class = shift; return WebGPU::Direct::RequestAdapterCallbackInfo->new(@_); }
  sub newRequestAdapterOptions { my $class = shift; return WebGPU::Direct::RequestAdapterOptions->new(@_); }
  sub newRequestDeviceCallbackInfo { my $class = shift; return WebGPU::Direct::RequestDeviceCallbackInfo->new(@_); }
  sub newSamplerBindingLayout { my $class = shift; return WebGPU::Direct::SamplerBindingLayout->new(@_); }
  sub newSamplerDescriptor { my $class = shift; return WebGPU::Direct::SamplerDescriptor->new(@_); }
  sub newShaderModuleDescriptor { my $class = shift; return WebGPU::Direct::ShaderModuleDescriptor->new(@_); }
  sub newShaderSourceSPIRV { my $class = shift; return WebGPU::Direct::ShaderSourceSPIRV->new(@_); }
  sub newShaderSourceWGSL { my $class = shift; return WebGPU::Direct::ShaderSourceWGSL->new(@_); }
  sub newStencilFaceState { my $class = shift; return WebGPU::Direct::StencilFaceState->new(@_); }
  sub newStorageTextureBindingLayout { my $class = shift; return WebGPU::Direct::StorageTextureBindingLayout->new(@_); }
  sub newStringView { my $class = shift; return WebGPU::Direct::StringView->new(@_); }
  sub newSupportedFeatures { my $class = shift; return WebGPU::Direct::SupportedFeatures->new(@_); }
  sub newSupportedWGSLLanguageFeatures { my $class = shift; return WebGPU::Direct::SupportedWGSLLanguageFeatures->new(@_); }
  sub newSurfaceCapabilities { my $class = shift; return WebGPU::Direct::SurfaceCapabilities->new(@_); }
  sub newSurfaceConfiguration { my $class = shift; return WebGPU::Direct::SurfaceConfiguration->new(@_); }
  sub newSurfaceDescriptor { my $class = shift; return WebGPU::Direct::SurfaceDescriptor->new(@_); }
  sub newSurfaceSourceAndroidNativeWindow { my $class = shift; return WebGPU::Direct::SurfaceSourceAndroidNativeWindow->new(@_); }
  sub newSurfaceSourceMetalLayer { my $class = shift; return WebGPU::Direct::SurfaceSourceMetalLayer->new(@_); }
  sub newSurfaceSourceWaylandSurface { my $class = shift; return WebGPU::Direct::SurfaceSourceWaylandSurface->new(@_); }
  sub newSurfaceSourceWindowsHWND { my $class = shift; return WebGPU::Direct::SurfaceSourceWindowsHWND->new(@_); }
  sub newSurfaceSourceXCBWindow { my $class = shift; return WebGPU::Direct::SurfaceSourceXCBWindow->new(@_); }
  sub newSurfaceSourceXlibWindow { my $class = shift; return WebGPU::Direct::SurfaceSourceXlibWindow->new(@_); }
  sub newSurfaceTexture { my $class = shift; return WebGPU::Direct::SurfaceTexture->new(@_); }
  sub newTexelCopyBufferInfo { my $class = shift; return WebGPU::Direct::TexelCopyBufferInfo->new(@_); }
  sub newTexelCopyBufferLayout { my $class = shift; return WebGPU::Direct::TexelCopyBufferLayout->new(@_); }
  sub newTexelCopyTextureInfo { my $class = shift; return WebGPU::Direct::TexelCopyTextureInfo->new(@_); }
  sub newTextureBindingLayout { my $class = shift; return WebGPU::Direct::TextureBindingLayout->new(@_); }
  sub newTextureDescriptor { my $class = shift; return WebGPU::Direct::TextureDescriptor->new(@_); }
  sub newTextureViewDescriptor { my $class = shift; return WebGPU::Direct::TextureViewDescriptor->new(@_); }
  sub newUncapturedErrorCallbackInfo { my $class = shift; return WebGPU::Direct::UncapturedErrorCallbackInfo->new(@_); }
  sub newVertexAttribute { my $class = shift; return WebGPU::Direct::VertexAttribute->new(@_); }
  sub newVertexBufferLayout { my $class = shift; return WebGPU::Direct::VertexBufferLayout->new(@_); }
  sub newVertexState { my $class = shift; return WebGPU::Direct::VertexState->new(@_); }
  sub ALIGN_OF_f16 () { 2 }; push @export_all, 'ALIGN_OF_f16';
  sub ALIGN_OF_f32 () { 4 }; push @export_all, 'ALIGN_OF_f32';
  sub ALIGN_OF_i32 () { 4 }; push @export_all, 'ALIGN_OF_i32';
  sub ALIGN_OF_u32 () { 4 }; push @export_all, 'ALIGN_OF_u32';
  sub BYTES_PER_f16 () { 2 }; push @export_all, 'BYTES_PER_f16';
  sub BYTES_PER_f32 () { 4 }; push @export_all, 'BYTES_PER_f32';
  sub BYTES_PER_i32 () { 4 }; push @export_all, 'BYTES_PER_i32';
  sub BYTES_PER_u32 () { 4 }; push @export_all, 'BYTES_PER_u32';
};

package
	WebGPU::Direct::AdapterType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('discreteGPU' => (0x00000001, 'WGPUAdapterType_DiscreteGPU'));
  __PACKAGE__->_add_enum('integratedGPU' => (0x00000002, 'WGPUAdapterType_IntegratedGPU'));
  __PACKAGE__->_add_enum('CPU' => (0x00000003, 'WGPUAdapterType_CPU'));
  __PACKAGE__->_add_enum('unknown' => (0x00000004, 'WGPUAdapterType_Unknown'));
  WebGPU::Direct::AdapterType->_build_const_lut;
};

package
	WebGPU::Direct::AddressMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUAddressMode_Undefined'));
  __PACKAGE__->_add_enum('clampToEdge' => (0x00000001, 'WGPUAddressMode_ClampToEdge'));
  __PACKAGE__->_add_enum('repeat' => (0x00000002, 'WGPUAddressMode_Repeat'));
  __PACKAGE__->_add_enum('mirrorRepeat' => (0x00000003, 'WGPUAddressMode_MirrorRepeat'));
  WebGPU::Direct::AddressMode->_build_const_lut;
};

package
	WebGPU::Direct::BackendType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUBackendType_Undefined'));
  __PACKAGE__->_add_enum('null' => (0x00000001, 'WGPUBackendType_Null'));
  __PACKAGE__->_add_enum('webGPU' => (0x00000002, 'WGPUBackendType_WebGPU'));
  __PACKAGE__->_add_enum('D3D11' => (0x00000003, 'WGPUBackendType_D3D11'));
  __PACKAGE__->_add_enum('D3D12' => (0x00000004, 'WGPUBackendType_D3D12'));
  __PACKAGE__->_add_enum('metal' => (0x00000005, 'WGPUBackendType_Metal'));
  __PACKAGE__->_add_enum('vulkan' => (0x00000006, 'WGPUBackendType_Vulkan'));
  __PACKAGE__->_add_enum('openGL' => (0x00000007, 'WGPUBackendType_OpenGL'));
  __PACKAGE__->_add_enum('openGLES' => (0x00000008, 'WGPUBackendType_OpenGLES'));
  WebGPU::Direct::BackendType->_build_const_lut;
};

package
	WebGPU::Direct::BlendFactor {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUBlendFactor_Undefined'));
  __PACKAGE__->_add_enum('zero' => (0x00000001, 'WGPUBlendFactor_Zero'));
  __PACKAGE__->_add_enum('one' => (0x00000002, 'WGPUBlendFactor_One'));
  __PACKAGE__->_add_enum('src' => (0x00000003, 'WGPUBlendFactor_Src'));
  __PACKAGE__->_add_enum('oneMinusSrc' => (0x00000004, 'WGPUBlendFactor_OneMinusSrc'));
  __PACKAGE__->_add_enum('srcAlpha' => (0x00000005, 'WGPUBlendFactor_SrcAlpha'));
  __PACKAGE__->_add_enum('oneMinusSrcAlpha' => (0x00000006, 'WGPUBlendFactor_OneMinusSrcAlpha'));
  __PACKAGE__->_add_enum('dst' => (0x00000007, 'WGPUBlendFactor_Dst'));
  __PACKAGE__->_add_enum('oneMinusDst' => (0x00000008, 'WGPUBlendFactor_OneMinusDst'));
  __PACKAGE__->_add_enum('dstAlpha' => (0x00000009, 'WGPUBlendFactor_DstAlpha'));
  __PACKAGE__->_add_enum('oneMinusDstAlpha' => (0x0000000A, 'WGPUBlendFactor_OneMinusDstAlpha'));
  __PACKAGE__->_add_enum('srcAlphaSaturated' => (0x0000000B, 'WGPUBlendFactor_SrcAlphaSaturated'));
  __PACKAGE__->_add_enum('constant' => (0x0000000C, 'WGPUBlendFactor_Constant'));
  __PACKAGE__->_add_enum('oneMinusConstant' => (0x0000000D, 'WGPUBlendFactor_OneMinusConstant'));
  __PACKAGE__->_add_enum('src1' => (0x0000000E, 'WGPUBlendFactor_Src1'));
  __PACKAGE__->_add_enum('oneMinusSrc1' => (0x0000000F, 'WGPUBlendFactor_OneMinusSrc1'));
  __PACKAGE__->_add_enum('src1Alpha' => (0x00000010, 'WGPUBlendFactor_Src1Alpha'));
  __PACKAGE__->_add_enum('oneMinusSrc1Alpha' => (0x00000011, 'WGPUBlendFactor_OneMinusSrc1Alpha'));
  WebGPU::Direct::BlendFactor->_build_const_lut;
};

package
	WebGPU::Direct::BlendOperation {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUBlendOperation_Undefined'));
  __PACKAGE__->_add_enum('add' => (0x00000001, 'WGPUBlendOperation_Add'));
  __PACKAGE__->_add_enum('subtract' => (0x00000002, 'WGPUBlendOperation_Subtract'));
  __PACKAGE__->_add_enum('reverseSubtract' => (0x00000003, 'WGPUBlendOperation_ReverseSubtract'));
  __PACKAGE__->_add_enum('min' => (0x00000004, 'WGPUBlendOperation_Min'));
  __PACKAGE__->_add_enum('max' => (0x00000005, 'WGPUBlendOperation_Max'));
  WebGPU::Direct::BlendOperation->_build_const_lut;
};

package
	WebGPU::Direct::BufferBindingType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('bindingNotUsed' => (0x00000000, 'WGPUBufferBindingType_BindingNotUsed'));
  __PACKAGE__->_add_enum('undefined' => (0x00000001, 'WGPUBufferBindingType_Undefined'));
  __PACKAGE__->_add_enum('uniform' => (0x00000002, 'WGPUBufferBindingType_Uniform'));
  __PACKAGE__->_add_enum('storage' => (0x00000003, 'WGPUBufferBindingType_Storage'));
  __PACKAGE__->_add_enum('readOnlyStorage' => (0x00000004, 'WGPUBufferBindingType_ReadOnlyStorage'));
  WebGPU::Direct::BufferBindingType->_build_const_lut;
};

package
	WebGPU::Direct::BufferMapState {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('unmapped' => (0x00000001, 'WGPUBufferMapState_Unmapped'));
  __PACKAGE__->_add_enum('pending' => (0x00000002, 'WGPUBufferMapState_Pending'));
  __PACKAGE__->_add_enum('mapped' => (0x00000003, 'WGPUBufferMapState_Mapped'));
  WebGPU::Direct::BufferMapState->_build_const_lut;
};

package
	WebGPU::Direct::BufferUsage {
  use base "WebGPU::Direct::Flag";
  __PACKAGE__->_add_enum('none' => (0x0000000000000000, 'WGPUBufferUsage_None'));
  __PACKAGE__->_add_enum('mapRead' => (0x0000000000000001, 'WGPUBufferUsage_MapRead'));
  __PACKAGE__->_add_enum('mapWrite' => (0x0000000000000002, 'WGPUBufferUsage_MapWrite'));
  __PACKAGE__->_add_enum('copySrc' => (0x0000000000000004, 'WGPUBufferUsage_CopySrc'));
  __PACKAGE__->_add_enum('copyDst' => (0x0000000000000008, 'WGPUBufferUsage_CopyDst'));
  __PACKAGE__->_add_enum('index' => (0x0000000000000010, 'WGPUBufferUsage_Index'));
  __PACKAGE__->_add_enum('vertex' => (0x0000000000000020, 'WGPUBufferUsage_Vertex'));
  __PACKAGE__->_add_enum('uniform' => (0x0000000000000040, 'WGPUBufferUsage_Uniform'));
  __PACKAGE__->_add_enum('storage' => (0x0000000000000080, 'WGPUBufferUsage_Storage'));
  __PACKAGE__->_add_enum('indirect' => (0x0000000000000100, 'WGPUBufferUsage_Indirect'));
  __PACKAGE__->_add_enum('queryResolve' => (0x0000000000000200, 'WGPUBufferUsage_QueryResolve'));
  WebGPU::Direct::BufferUsage->_build_const_lut;
};

package
	WebGPU::Direct::CallbackMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('waitAnyOnly' => (0x00000001, 'WGPUCallbackMode_WaitAnyOnly'));
  __PACKAGE__->_add_enum('allowProcessEvents' => (0x00000002, 'WGPUCallbackMode_AllowProcessEvents'));
  __PACKAGE__->_add_enum('allowSpontaneous' => (0x00000003, 'WGPUCallbackMode_AllowSpontaneous'));
  WebGPU::Direct::CallbackMode->_build_const_lut;
};

package
	WebGPU::Direct::ColorWriteMask {
  use base "WebGPU::Direct::Flag";
  __PACKAGE__->_add_enum('none' => (0x0000000000000000, 'WGPUColorWriteMask_None'));
  __PACKAGE__->_add_enum('red' => (0x0000000000000001, 'WGPUColorWriteMask_Red'));
  __PACKAGE__->_add_enum('green' => (0x0000000000000002, 'WGPUColorWriteMask_Green'));
  __PACKAGE__->_add_enum('blue' => (0x0000000000000004, 'WGPUColorWriteMask_Blue'));
  __PACKAGE__->_add_enum('alpha' => (0x0000000000000008, 'WGPUColorWriteMask_Alpha'));
  __PACKAGE__->_add_enum('all' => (0x000000000000000F, 'WGPUColorWriteMask_All'));
  WebGPU::Direct::ColorWriteMask->_build_const_lut;
};

package
	WebGPU::Direct::CompareFunction {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUCompareFunction_Undefined'));
  __PACKAGE__->_add_enum('never' => (0x00000001, 'WGPUCompareFunction_Never'));
  __PACKAGE__->_add_enum('less' => (0x00000002, 'WGPUCompareFunction_Less'));
  __PACKAGE__->_add_enum('equal' => (0x00000003, 'WGPUCompareFunction_Equal'));
  __PACKAGE__->_add_enum('lessEqual' => (0x00000004, 'WGPUCompareFunction_LessEqual'));
  __PACKAGE__->_add_enum('greater' => (0x00000005, 'WGPUCompareFunction_Greater'));
  __PACKAGE__->_add_enum('notEqual' => (0x00000006, 'WGPUCompareFunction_NotEqual'));
  __PACKAGE__->_add_enum('greaterEqual' => (0x00000007, 'WGPUCompareFunction_GreaterEqual'));
  __PACKAGE__->_add_enum('always' => (0x00000008, 'WGPUCompareFunction_Always'));
  WebGPU::Direct::CompareFunction->_build_const_lut;
};

package
	WebGPU::Direct::CompilationInfoRequestStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUCompilationInfoRequestStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPUCompilationInfoRequestStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('error' => (0x00000003, 'WGPUCompilationInfoRequestStatus_Error'));
  __PACKAGE__->_add_enum('unknown' => (0x00000004, 'WGPUCompilationInfoRequestStatus_Unknown'));
  WebGPU::Direct::CompilationInfoRequestStatus->_build_const_lut;
};

package
	WebGPU::Direct::CompilationMessageType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('error' => (0x00000001, 'WGPUCompilationMessageType_Error'));
  __PACKAGE__->_add_enum('warning' => (0x00000002, 'WGPUCompilationMessageType_Warning'));
  __PACKAGE__->_add_enum('info' => (0x00000003, 'WGPUCompilationMessageType_Info'));
  WebGPU::Direct::CompilationMessageType->_build_const_lut;
};

package
	WebGPU::Direct::CompositeAlphaMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('auto' => (0x00000000, 'WGPUCompositeAlphaMode_Auto'));
  __PACKAGE__->_add_enum('opaque' => (0x00000001, 'WGPUCompositeAlphaMode_Opaque'));
  __PACKAGE__->_add_enum('premultiplied' => (0x00000002, 'WGPUCompositeAlphaMode_Premultiplied'));
  __PACKAGE__->_add_enum('unpremultiplied' => (0x00000003, 'WGPUCompositeAlphaMode_Unpremultiplied'));
  __PACKAGE__->_add_enum('inherit' => (0x00000004, 'WGPUCompositeAlphaMode_Inherit'));
  WebGPU::Direct::CompositeAlphaMode->_build_const_lut;
};

package
	WebGPU::Direct::CreatePipelineAsyncStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUCreatePipelineAsyncStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPUCreatePipelineAsyncStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('validationError' => (0x00000003, 'WGPUCreatePipelineAsyncStatus_ValidationError'));
  __PACKAGE__->_add_enum('internalError' => (0x00000004, 'WGPUCreatePipelineAsyncStatus_InternalError'));
  __PACKAGE__->_add_enum('unknown' => (0x00000005, 'WGPUCreatePipelineAsyncStatus_Unknown'));
  WebGPU::Direct::CreatePipelineAsyncStatus->_build_const_lut;
};

package
	WebGPU::Direct::CullMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUCullMode_Undefined'));
  __PACKAGE__->_add_enum('none' => (0x00000001, 'WGPUCullMode_None'));
  __PACKAGE__->_add_enum('front' => (0x00000002, 'WGPUCullMode_Front'));
  __PACKAGE__->_add_enum('back' => (0x00000003, 'WGPUCullMode_Back'));
  WebGPU::Direct::CullMode->_build_const_lut;
};

package
	WebGPU::Direct::DeviceLostReason {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('unknown' => (0x00000001, 'WGPUDeviceLostReason_Unknown'));
  __PACKAGE__->_add_enum('destroyed' => (0x00000002, 'WGPUDeviceLostReason_Destroyed'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000003, 'WGPUDeviceLostReason_InstanceDropped'));
  __PACKAGE__->_add_enum('failedCreation' => (0x00000004, 'WGPUDeviceLostReason_FailedCreation'));
  WebGPU::Direct::DeviceLostReason->_build_const_lut;
};

package
	WebGPU::Direct::ErrorFilter {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('validation' => (0x00000001, 'WGPUErrorFilter_Validation'));
  __PACKAGE__->_add_enum('outOfMemory' => (0x00000002, 'WGPUErrorFilter_OutOfMemory'));
  __PACKAGE__->_add_enum('internal' => (0x00000003, 'WGPUErrorFilter_Internal'));
  WebGPU::Direct::ErrorFilter->_build_const_lut;
};

package
	WebGPU::Direct::ErrorType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('noError' => (0x00000001, 'WGPUErrorType_NoError'));
  __PACKAGE__->_add_enum('validation' => (0x00000002, 'WGPUErrorType_Validation'));
  __PACKAGE__->_add_enum('outOfMemory' => (0x00000003, 'WGPUErrorType_OutOfMemory'));
  __PACKAGE__->_add_enum('internal' => (0x00000004, 'WGPUErrorType_Internal'));
  __PACKAGE__->_add_enum('unknown' => (0x00000005, 'WGPUErrorType_Unknown'));
  WebGPU::Direct::ErrorType->_build_const_lut;
};

package
	WebGPU::Direct::FeatureLevel {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('compatibility' => (0x00000001, 'WGPUFeatureLevel_Compatibility'));
  __PACKAGE__->_add_enum('core' => (0x00000002, 'WGPUFeatureLevel_Core'));
  WebGPU::Direct::FeatureLevel->_build_const_lut;
};

package
	WebGPU::Direct::FeatureName {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUFeatureName_Undefined'));
  __PACKAGE__->_add_enum('depthClipControl' => (0x00000001, 'WGPUFeatureName_DepthClipControl'));
  __PACKAGE__->_add_enum('depth32FloatStencil8' => (0x00000002, 'WGPUFeatureName_Depth32FloatStencil8'));
  __PACKAGE__->_add_enum('timestampQuery' => (0x00000003, 'WGPUFeatureName_TimestampQuery'));
  __PACKAGE__->_add_enum('textureCompressionBC' => (0x00000004, 'WGPUFeatureName_TextureCompressionBC'));
  __PACKAGE__->_add_enum('textureCompressionBCSliced3D' => (0x00000005, 'WGPUFeatureName_TextureCompressionBCSliced3D'));
  __PACKAGE__->_add_enum('textureCompressionETC2' => (0x00000006, 'WGPUFeatureName_TextureCompressionETC2'));
  __PACKAGE__->_add_enum('textureCompressionASTC' => (0x00000007, 'WGPUFeatureName_TextureCompressionASTC'));
  __PACKAGE__->_add_enum('textureCompressionASTCSliced3D' => (0x00000008, 'WGPUFeatureName_TextureCompressionASTCSliced3D'));
  __PACKAGE__->_add_enum('indirectFirstInstance' => (0x00000009, 'WGPUFeatureName_IndirectFirstInstance'));
  __PACKAGE__->_add_enum('shaderF16' => (0x0000000A, 'WGPUFeatureName_ShaderF16'));
  __PACKAGE__->_add_enum('RG11B10UfloatRenderable' => (0x0000000B, 'WGPUFeatureName_RG11B10UfloatRenderable'));
  __PACKAGE__->_add_enum('BGRA8UnormStorage' => (0x0000000C, 'WGPUFeatureName_BGRA8UnormStorage'));
  __PACKAGE__->_add_enum('float32Filterable' => (0x0000000D, 'WGPUFeatureName_Float32Filterable'));
  __PACKAGE__->_add_enum('float32Blendable' => (0x0000000E, 'WGPUFeatureName_Float32Blendable'));
  __PACKAGE__->_add_enum('clipDistances' => (0x0000000F, 'WGPUFeatureName_ClipDistances'));
  __PACKAGE__->_add_enum('dualSourceBlending' => (0x00000010, 'WGPUFeatureName_DualSourceBlending'));
  WebGPU::Direct::FeatureName->_build_const_lut;
};

package
	WebGPU::Direct::FilterMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUFilterMode_Undefined'));
  __PACKAGE__->_add_enum('nearest' => (0x00000001, 'WGPUFilterMode_Nearest'));
  __PACKAGE__->_add_enum('linear' => (0x00000002, 'WGPUFilterMode_Linear'));
  WebGPU::Direct::FilterMode->_build_const_lut;
};

package
	WebGPU::Direct::FrontFace {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUFrontFace_Undefined'));
  __PACKAGE__->_add_enum('CCW' => (0x00000001, 'WGPUFrontFace_CCW'));
  __PACKAGE__->_add_enum('CW' => (0x00000002, 'WGPUFrontFace_CW'));
  WebGPU::Direct::FrontFace->_build_const_lut;
};

package
	WebGPU::Direct::IndexFormat {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUIndexFormat_Undefined'));
  __PACKAGE__->_add_enum('uint16' => (0x00000001, 'WGPUIndexFormat_Uint16'));
  __PACKAGE__->_add_enum('uint32' => (0x00000002, 'WGPUIndexFormat_Uint32'));
  WebGPU::Direct::IndexFormat->_build_const_lut;
};

package
	WebGPU::Direct::LoadOp {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPULoadOp_Undefined'));
  __PACKAGE__->_add_enum('load' => (0x00000001, 'WGPULoadOp_Load'));
  __PACKAGE__->_add_enum('clear' => (0x00000002, 'WGPULoadOp_Clear'));
  WebGPU::Direct::LoadOp->_build_const_lut;
};

package
	WebGPU::Direct::MapAsyncStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUMapAsyncStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPUMapAsyncStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('error' => (0x00000003, 'WGPUMapAsyncStatus_Error'));
  __PACKAGE__->_add_enum('aborted' => (0x00000004, 'WGPUMapAsyncStatus_Aborted'));
  __PACKAGE__->_add_enum('unknown' => (0x00000005, 'WGPUMapAsyncStatus_Unknown'));
  WebGPU::Direct::MapAsyncStatus->_build_const_lut;
};

package
	WebGPU::Direct::MapMode {
  use base "WebGPU::Direct::Flag";
  __PACKAGE__->_add_enum('none' => (0x0000000000000000, 'WGPUMapMode_None'));
  __PACKAGE__->_add_enum('read' => (0x0000000000000001, 'WGPUMapMode_Read'));
  __PACKAGE__->_add_enum('write' => (0x0000000000000002, 'WGPUMapMode_Write'));
  WebGPU::Direct::MapMode->_build_const_lut;
};

package
	WebGPU::Direct::MipmapFilterMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUMipmapFilterMode_Undefined'));
  __PACKAGE__->_add_enum('nearest' => (0x00000001, 'WGPUMipmapFilterMode_Nearest'));
  __PACKAGE__->_add_enum('linear' => (0x00000002, 'WGPUMipmapFilterMode_Linear'));
  WebGPU::Direct::MipmapFilterMode->_build_const_lut;
};

package
	WebGPU::Direct::OptionalBool {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('false' => (0x00000000, 'WGPUOptionalBool_False'));
  __PACKAGE__->_add_enum('true' => (0x00000001, 'WGPUOptionalBool_True'));
  __PACKAGE__->_add_enum('undefined' => (0x00000002, 'WGPUOptionalBool_Undefined'));
  WebGPU::Direct::OptionalBool->_build_const_lut;
};

package
	WebGPU::Direct::PopErrorScopeStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUPopErrorScopeStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPUPopErrorScopeStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('emptyStack' => (0x00000003, 'WGPUPopErrorScopeStatus_EmptyStack'));
  WebGPU::Direct::PopErrorScopeStatus->_build_const_lut;
};

package
	WebGPU::Direct::PowerPreference {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUPowerPreference_Undefined'));
  __PACKAGE__->_add_enum('lowPower' => (0x00000001, 'WGPUPowerPreference_LowPower'));
  __PACKAGE__->_add_enum('highPerformance' => (0x00000002, 'WGPUPowerPreference_HighPerformance'));
  WebGPU::Direct::PowerPreference->_build_const_lut;
};

package
	WebGPU::Direct::PresentMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUPresentMode_Undefined'));
  __PACKAGE__->_add_enum('fifo' => (0x00000001, 'WGPUPresentMode_Fifo'));
  __PACKAGE__->_add_enum('fifoRelaxed' => (0x00000002, 'WGPUPresentMode_FifoRelaxed'));
  __PACKAGE__->_add_enum('immediate' => (0x00000003, 'WGPUPresentMode_Immediate'));
  __PACKAGE__->_add_enum('mailbox' => (0x00000004, 'WGPUPresentMode_Mailbox'));
  WebGPU::Direct::PresentMode->_build_const_lut;
};

package
	WebGPU::Direct::PrimitiveTopology {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUPrimitiveTopology_Undefined'));
  __PACKAGE__->_add_enum('pointList' => (0x00000001, 'WGPUPrimitiveTopology_PointList'));
  __PACKAGE__->_add_enum('lineList' => (0x00000002, 'WGPUPrimitiveTopology_LineList'));
  __PACKAGE__->_add_enum('lineStrip' => (0x00000003, 'WGPUPrimitiveTopology_LineStrip'));
  __PACKAGE__->_add_enum('triangleList' => (0x00000004, 'WGPUPrimitiveTopology_TriangleList'));
  __PACKAGE__->_add_enum('triangleStrip' => (0x00000005, 'WGPUPrimitiveTopology_TriangleStrip'));
  WebGPU::Direct::PrimitiveTopology->_build_const_lut;
};

package
	WebGPU::Direct::QueryType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('occlusion' => (0x00000001, 'WGPUQueryType_Occlusion'));
  __PACKAGE__->_add_enum('timestamp' => (0x00000002, 'WGPUQueryType_Timestamp'));
  WebGPU::Direct::QueryType->_build_const_lut;
};

package
	WebGPU::Direct::QueueWorkDoneStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUQueueWorkDoneStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPUQueueWorkDoneStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('error' => (0x00000003, 'WGPUQueueWorkDoneStatus_Error'));
  __PACKAGE__->_add_enum('unknown' => (0x00000004, 'WGPUQueueWorkDoneStatus_Unknown'));
  WebGPU::Direct::QueueWorkDoneStatus->_build_const_lut;
};

package
	WebGPU::Direct::RequestAdapterStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPURequestAdapterStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPURequestAdapterStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('unavailable' => (0x00000003, 'WGPURequestAdapterStatus_Unavailable'));
  __PACKAGE__->_add_enum('error' => (0x00000004, 'WGPURequestAdapterStatus_Error'));
  __PACKAGE__->_add_enum('unknown' => (0x00000005, 'WGPURequestAdapterStatus_Unknown'));
  WebGPU::Direct::RequestAdapterStatus->_build_const_lut;
};

package
	WebGPU::Direct::RequestDeviceStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPURequestDeviceStatus_Success'));
  __PACKAGE__->_add_enum('instanceDropped' => (0x00000002, 'WGPURequestDeviceStatus_InstanceDropped'));
  __PACKAGE__->_add_enum('error' => (0x00000003, 'WGPURequestDeviceStatus_Error'));
  __PACKAGE__->_add_enum('unknown' => (0x00000004, 'WGPURequestDeviceStatus_Unknown'));
  WebGPU::Direct::RequestDeviceStatus->_build_const_lut;
};

package
	WebGPU::Direct::SType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('shaderSourceSPIRV' => (0x00000001, 'WGPUSType_ShaderSourceSPIRV'));
  __PACKAGE__->_add_enum('shaderSourceWGSL' => (0x00000002, 'WGPUSType_ShaderSourceWGSL'));
  __PACKAGE__->_add_enum('renderPassMaxDrawCount' => (0x00000003, 'WGPUSType_RenderPassMaxDrawCount'));
  __PACKAGE__->_add_enum('surfaceSourceMetalLayer' => (0x00000004, 'WGPUSType_SurfaceSourceMetalLayer'));
  __PACKAGE__->_add_enum('surfaceSourceWindowsHWND' => (0x00000005, 'WGPUSType_SurfaceSourceWindowsHWND'));
  __PACKAGE__->_add_enum('surfaceSourceXlibWindow' => (0x00000006, 'WGPUSType_SurfaceSourceXlibWindow'));
  __PACKAGE__->_add_enum('surfaceSourceWaylandSurface' => (0x00000007, 'WGPUSType_SurfaceSourceWaylandSurface'));
  __PACKAGE__->_add_enum('surfaceSourceAndroidNativeWindow' => (0x00000008, 'WGPUSType_SurfaceSourceAndroidNativeWindow'));
  __PACKAGE__->_add_enum('surfaceSourceXCBWindow' => (0x00000009, 'WGPUSType_SurfaceSourceXCBWindow'));
  WebGPU::Direct::SType->_build_const_lut;
};

package
	WebGPU::Direct::SamplerBindingType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('bindingNotUsed' => (0x00000000, 'WGPUSamplerBindingType_BindingNotUsed'));
  __PACKAGE__->_add_enum('undefined' => (0x00000001, 'WGPUSamplerBindingType_Undefined'));
  __PACKAGE__->_add_enum('filtering' => (0x00000002, 'WGPUSamplerBindingType_Filtering'));
  __PACKAGE__->_add_enum('nonFiltering' => (0x00000003, 'WGPUSamplerBindingType_NonFiltering'));
  __PACKAGE__->_add_enum('comparison' => (0x00000004, 'WGPUSamplerBindingType_Comparison'));
  WebGPU::Direct::SamplerBindingType->_build_const_lut;
};

package
	WebGPU::Direct::ShaderStage {
  use base "WebGPU::Direct::Flag";
  __PACKAGE__->_add_enum('none' => (0x0000000000000000, 'WGPUShaderStage_None'));
  __PACKAGE__->_add_enum('vertex' => (0x0000000000000001, 'WGPUShaderStage_Vertex'));
  __PACKAGE__->_add_enum('fragment' => (0x0000000000000002, 'WGPUShaderStage_Fragment'));
  __PACKAGE__->_add_enum('compute' => (0x0000000000000004, 'WGPUShaderStage_Compute'));
  WebGPU::Direct::ShaderStage->_build_const_lut;
};

package
	WebGPU::Direct::Status {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUStatus_Success'));
  __PACKAGE__->_add_enum('error' => (0x00000002, 'WGPUStatus_Error'));
  WebGPU::Direct::Status->_build_const_lut;
};

package
	WebGPU::Direct::StencilOperation {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUStencilOperation_Undefined'));
  __PACKAGE__->_add_enum('keep' => (0x00000001, 'WGPUStencilOperation_Keep'));
  __PACKAGE__->_add_enum('zero' => (0x00000002, 'WGPUStencilOperation_Zero'));
  __PACKAGE__->_add_enum('replace' => (0x00000003, 'WGPUStencilOperation_Replace'));
  __PACKAGE__->_add_enum('invert' => (0x00000004, 'WGPUStencilOperation_Invert'));
  __PACKAGE__->_add_enum('incrementClamp' => (0x00000005, 'WGPUStencilOperation_IncrementClamp'));
  __PACKAGE__->_add_enum('decrementClamp' => (0x00000006, 'WGPUStencilOperation_DecrementClamp'));
  __PACKAGE__->_add_enum('incrementWrap' => (0x00000007, 'WGPUStencilOperation_IncrementWrap'));
  __PACKAGE__->_add_enum('decrementWrap' => (0x00000008, 'WGPUStencilOperation_DecrementWrap'));
  WebGPU::Direct::StencilOperation->_build_const_lut;
};

package
	WebGPU::Direct::StorageTextureAccess {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('bindingNotUsed' => (0x00000000, 'WGPUStorageTextureAccess_BindingNotUsed'));
  __PACKAGE__->_add_enum('undefined' => (0x00000001, 'WGPUStorageTextureAccess_Undefined'));
  __PACKAGE__->_add_enum('writeOnly' => (0x00000002, 'WGPUStorageTextureAccess_WriteOnly'));
  __PACKAGE__->_add_enum('readOnly' => (0x00000003, 'WGPUStorageTextureAccess_ReadOnly'));
  __PACKAGE__->_add_enum('readWrite' => (0x00000004, 'WGPUStorageTextureAccess_ReadWrite'));
  WebGPU::Direct::StorageTextureAccess->_build_const_lut;
};

package
	WebGPU::Direct::StoreOp {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUStoreOp_Undefined'));
  __PACKAGE__->_add_enum('store' => (0x00000001, 'WGPUStoreOp_Store'));
  __PACKAGE__->_add_enum('discard' => (0x00000002, 'WGPUStoreOp_Discard'));
  WebGPU::Direct::StoreOp->_build_const_lut;
};

package
	WebGPU::Direct::SurfaceGetCurrentTextureStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('successOptimal' => (0x00000001, 'WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal'));
  __PACKAGE__->_add_enum('successSuboptimal' => (0x00000002, 'WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal'));
  __PACKAGE__->_add_enum('timeout' => (0x00000003, 'WGPUSurfaceGetCurrentTextureStatus_Timeout'));
  __PACKAGE__->_add_enum('outdated' => (0x00000004, 'WGPUSurfaceGetCurrentTextureStatus_Outdated'));
  __PACKAGE__->_add_enum('lost' => (0x00000005, 'WGPUSurfaceGetCurrentTextureStatus_Lost'));
  __PACKAGE__->_add_enum('outOfMemory' => (0x00000006, 'WGPUSurfaceGetCurrentTextureStatus_OutOfMemory'));
  __PACKAGE__->_add_enum('deviceLost' => (0x00000007, 'WGPUSurfaceGetCurrentTextureStatus_DeviceLost'));
  __PACKAGE__->_add_enum('error' => (0x00000008, 'WGPUSurfaceGetCurrentTextureStatus_Error'));
  WebGPU::Direct::SurfaceGetCurrentTextureStatus->_build_const_lut;
};

package
	WebGPU::Direct::TextureAspect {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUTextureAspect_Undefined'));
  __PACKAGE__->_add_enum('all' => (0x00000001, 'WGPUTextureAspect_All'));
  __PACKAGE__->_add_enum('stencilOnly' => (0x00000002, 'WGPUTextureAspect_StencilOnly'));
  __PACKAGE__->_add_enum('depthOnly' => (0x00000003, 'WGPUTextureAspect_DepthOnly'));
  WebGPU::Direct::TextureAspect->_build_const_lut;
};

package
	WebGPU::Direct::TextureDimension {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUTextureDimension_Undefined'));
  __PACKAGE__->_add_enum('_1D' => (0x00000001, 'WGPUTextureDimension_1D'));
  __PACKAGE__->_add_enum('_2D' => (0x00000002, 'WGPUTextureDimension_2D'));
  __PACKAGE__->_add_enum('_3D' => (0x00000003, 'WGPUTextureDimension_3D'));
  WebGPU::Direct::TextureDimension->_build_const_lut;
};

package
	WebGPU::Direct::TextureFormat {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUTextureFormat_Undefined'));
  __PACKAGE__->_add_enum('R8Unorm' => (0x00000001, 'WGPUTextureFormat_R8Unorm'));
  __PACKAGE__->_add_enum('R8Snorm' => (0x00000002, 'WGPUTextureFormat_R8Snorm'));
  __PACKAGE__->_add_enum('R8Uint' => (0x00000003, 'WGPUTextureFormat_R8Uint'));
  __PACKAGE__->_add_enum('R8Sint' => (0x00000004, 'WGPUTextureFormat_R8Sint'));
  __PACKAGE__->_add_enum('R16Uint' => (0x00000005, 'WGPUTextureFormat_R16Uint'));
  __PACKAGE__->_add_enum('R16Sint' => (0x00000006, 'WGPUTextureFormat_R16Sint'));
  __PACKAGE__->_add_enum('R16Float' => (0x00000007, 'WGPUTextureFormat_R16Float'));
  __PACKAGE__->_add_enum('RG8Unorm' => (0x00000008, 'WGPUTextureFormat_RG8Unorm'));
  __PACKAGE__->_add_enum('RG8Snorm' => (0x00000009, 'WGPUTextureFormat_RG8Snorm'));
  __PACKAGE__->_add_enum('RG8Uint' => (0x0000000A, 'WGPUTextureFormat_RG8Uint'));
  __PACKAGE__->_add_enum('RG8Sint' => (0x0000000B, 'WGPUTextureFormat_RG8Sint'));
  __PACKAGE__->_add_enum('R32Float' => (0x0000000C, 'WGPUTextureFormat_R32Float'));
  __PACKAGE__->_add_enum('R32Uint' => (0x0000000D, 'WGPUTextureFormat_R32Uint'));
  __PACKAGE__->_add_enum('R32Sint' => (0x0000000E, 'WGPUTextureFormat_R32Sint'));
  __PACKAGE__->_add_enum('RG16Uint' => (0x0000000F, 'WGPUTextureFormat_RG16Uint'));
  __PACKAGE__->_add_enum('RG16Sint' => (0x00000010, 'WGPUTextureFormat_RG16Sint'));
  __PACKAGE__->_add_enum('RG16Float' => (0x00000011, 'WGPUTextureFormat_RG16Float'));
  __PACKAGE__->_add_enum('RGBA8Unorm' => (0x00000012, 'WGPUTextureFormat_RGBA8Unorm'));
  __PACKAGE__->_add_enum('RGBA8UnormSrgb' => (0x00000013, 'WGPUTextureFormat_RGBA8UnormSrgb'));
  __PACKAGE__->_add_enum('RGBA8Snorm' => (0x00000014, 'WGPUTextureFormat_RGBA8Snorm'));
  __PACKAGE__->_add_enum('RGBA8Uint' => (0x00000015, 'WGPUTextureFormat_RGBA8Uint'));
  __PACKAGE__->_add_enum('RGBA8Sint' => (0x00000016, 'WGPUTextureFormat_RGBA8Sint'));
  __PACKAGE__->_add_enum('BGRA8Unorm' => (0x00000017, 'WGPUTextureFormat_BGRA8Unorm'));
  __PACKAGE__->_add_enum('BGRA8UnormSrgb' => (0x00000018, 'WGPUTextureFormat_BGRA8UnormSrgb'));
  __PACKAGE__->_add_enum('RGB10A2Uint' => (0x00000019, 'WGPUTextureFormat_RGB10A2Uint'));
  __PACKAGE__->_add_enum('RGB10A2Unorm' => (0x0000001A, 'WGPUTextureFormat_RGB10A2Unorm'));
  __PACKAGE__->_add_enum('RG11B10Ufloat' => (0x0000001B, 'WGPUTextureFormat_RG11B10Ufloat'));
  __PACKAGE__->_add_enum('RGB9E5Ufloat' => (0x0000001C, 'WGPUTextureFormat_RGB9E5Ufloat'));
  __PACKAGE__->_add_enum('RG32Float' => (0x0000001D, 'WGPUTextureFormat_RG32Float'));
  __PACKAGE__->_add_enum('RG32Uint' => (0x0000001E, 'WGPUTextureFormat_RG32Uint'));
  __PACKAGE__->_add_enum('RG32Sint' => (0x0000001F, 'WGPUTextureFormat_RG32Sint'));
  __PACKAGE__->_add_enum('RGBA16Uint' => (0x00000020, 'WGPUTextureFormat_RGBA16Uint'));
  __PACKAGE__->_add_enum('RGBA16Sint' => (0x00000021, 'WGPUTextureFormat_RGBA16Sint'));
  __PACKAGE__->_add_enum('RGBA16Float' => (0x00000022, 'WGPUTextureFormat_RGBA16Float'));
  __PACKAGE__->_add_enum('RGBA32Float' => (0x00000023, 'WGPUTextureFormat_RGBA32Float'));
  __PACKAGE__->_add_enum('RGBA32Uint' => (0x00000024, 'WGPUTextureFormat_RGBA32Uint'));
  __PACKAGE__->_add_enum('RGBA32Sint' => (0x00000025, 'WGPUTextureFormat_RGBA32Sint'));
  __PACKAGE__->_add_enum('stencil8' => (0x00000026, 'WGPUTextureFormat_Stencil8'));
  __PACKAGE__->_add_enum('depth16Unorm' => (0x00000027, 'WGPUTextureFormat_Depth16Unorm'));
  __PACKAGE__->_add_enum('depth24Plus' => (0x00000028, 'WGPUTextureFormat_Depth24Plus'));
  __PACKAGE__->_add_enum('depth24PlusStencil8' => (0x00000029, 'WGPUTextureFormat_Depth24PlusStencil8'));
  __PACKAGE__->_add_enum('depth32Float' => (0x0000002A, 'WGPUTextureFormat_Depth32Float'));
  __PACKAGE__->_add_enum('depth32FloatStencil8' => (0x0000002B, 'WGPUTextureFormat_Depth32FloatStencil8'));
  __PACKAGE__->_add_enum('BC1RGBAUnorm' => (0x0000002C, 'WGPUTextureFormat_BC1RGBAUnorm'));
  __PACKAGE__->_add_enum('BC1RGBAUnormSrgb' => (0x0000002D, 'WGPUTextureFormat_BC1RGBAUnormSrgb'));
  __PACKAGE__->_add_enum('BC2RGBAUnorm' => (0x0000002E, 'WGPUTextureFormat_BC2RGBAUnorm'));
  __PACKAGE__->_add_enum('BC2RGBAUnormSrgb' => (0x0000002F, 'WGPUTextureFormat_BC2RGBAUnormSrgb'));
  __PACKAGE__->_add_enum('BC3RGBAUnorm' => (0x00000030, 'WGPUTextureFormat_BC3RGBAUnorm'));
  __PACKAGE__->_add_enum('BC3RGBAUnormSrgb' => (0x00000031, 'WGPUTextureFormat_BC3RGBAUnormSrgb'));
  __PACKAGE__->_add_enum('BC4RUnorm' => (0x00000032, 'WGPUTextureFormat_BC4RUnorm'));
  __PACKAGE__->_add_enum('BC4RSnorm' => (0x00000033, 'WGPUTextureFormat_BC4RSnorm'));
  __PACKAGE__->_add_enum('BC5RGUnorm' => (0x00000034, 'WGPUTextureFormat_BC5RGUnorm'));
  __PACKAGE__->_add_enum('BC5RGSnorm' => (0x00000035, 'WGPUTextureFormat_BC5RGSnorm'));
  __PACKAGE__->_add_enum('BC6HRGBUfloat' => (0x00000036, 'WGPUTextureFormat_BC6HRGBUfloat'));
  __PACKAGE__->_add_enum('BC6HRGBFloat' => (0x00000037, 'WGPUTextureFormat_BC6HRGBFloat'));
  __PACKAGE__->_add_enum('BC7RGBAUnorm' => (0x00000038, 'WGPUTextureFormat_BC7RGBAUnorm'));
  __PACKAGE__->_add_enum('BC7RGBAUnormSrgb' => (0x00000039, 'WGPUTextureFormat_BC7RGBAUnormSrgb'));
  __PACKAGE__->_add_enum('ETC2RGB8Unorm' => (0x0000003A, 'WGPUTextureFormat_ETC2RGB8Unorm'));
  __PACKAGE__->_add_enum('ETC2RGB8UnormSrgb' => (0x0000003B, 'WGPUTextureFormat_ETC2RGB8UnormSrgb'));
  __PACKAGE__->_add_enum('ETC2RGB8A1Unorm' => (0x0000003C, 'WGPUTextureFormat_ETC2RGB8A1Unorm'));
  __PACKAGE__->_add_enum('ETC2RGB8A1UnormSrgb' => (0x0000003D, 'WGPUTextureFormat_ETC2RGB8A1UnormSrgb'));
  __PACKAGE__->_add_enum('ETC2RGBA8Unorm' => (0x0000003E, 'WGPUTextureFormat_ETC2RGBA8Unorm'));
  __PACKAGE__->_add_enum('ETC2RGBA8UnormSrgb' => (0x0000003F, 'WGPUTextureFormat_ETC2RGBA8UnormSrgb'));
  __PACKAGE__->_add_enum('EACR11Unorm' => (0x00000040, 'WGPUTextureFormat_EACR11Unorm'));
  __PACKAGE__->_add_enum('EACR11Snorm' => (0x00000041, 'WGPUTextureFormat_EACR11Snorm'));
  __PACKAGE__->_add_enum('EACRG11Unorm' => (0x00000042, 'WGPUTextureFormat_EACRG11Unorm'));
  __PACKAGE__->_add_enum('EACRG11Snorm' => (0x00000043, 'WGPUTextureFormat_EACRG11Snorm'));
  __PACKAGE__->_add_enum('ASTC4x4Unorm' => (0x00000044, 'WGPUTextureFormat_ASTC4x4Unorm'));
  __PACKAGE__->_add_enum('ASTC4x4UnormSrgb' => (0x00000045, 'WGPUTextureFormat_ASTC4x4UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC5x4Unorm' => (0x00000046, 'WGPUTextureFormat_ASTC5x4Unorm'));
  __PACKAGE__->_add_enum('ASTC5x4UnormSrgb' => (0x00000047, 'WGPUTextureFormat_ASTC5x4UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC5x5Unorm' => (0x00000048, 'WGPUTextureFormat_ASTC5x5Unorm'));
  __PACKAGE__->_add_enum('ASTC5x5UnormSrgb' => (0x00000049, 'WGPUTextureFormat_ASTC5x5UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC6x5Unorm' => (0x0000004A, 'WGPUTextureFormat_ASTC6x5Unorm'));
  __PACKAGE__->_add_enum('ASTC6x5UnormSrgb' => (0x0000004B, 'WGPUTextureFormat_ASTC6x5UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC6x6Unorm' => (0x0000004C, 'WGPUTextureFormat_ASTC6x6Unorm'));
  __PACKAGE__->_add_enum('ASTC6x6UnormSrgb' => (0x0000004D, 'WGPUTextureFormat_ASTC6x6UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC8x5Unorm' => (0x0000004E, 'WGPUTextureFormat_ASTC8x5Unorm'));
  __PACKAGE__->_add_enum('ASTC8x5UnormSrgb' => (0x0000004F, 'WGPUTextureFormat_ASTC8x5UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC8x6Unorm' => (0x00000050, 'WGPUTextureFormat_ASTC8x6Unorm'));
  __PACKAGE__->_add_enum('ASTC8x6UnormSrgb' => (0x00000051, 'WGPUTextureFormat_ASTC8x6UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC8x8Unorm' => (0x00000052, 'WGPUTextureFormat_ASTC8x8Unorm'));
  __PACKAGE__->_add_enum('ASTC8x8UnormSrgb' => (0x00000053, 'WGPUTextureFormat_ASTC8x8UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC10x5Unorm' => (0x00000054, 'WGPUTextureFormat_ASTC10x5Unorm'));
  __PACKAGE__->_add_enum('ASTC10x5UnormSrgb' => (0x00000055, 'WGPUTextureFormat_ASTC10x5UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC10x6Unorm' => (0x00000056, 'WGPUTextureFormat_ASTC10x6Unorm'));
  __PACKAGE__->_add_enum('ASTC10x6UnormSrgb' => (0x00000057, 'WGPUTextureFormat_ASTC10x6UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC10x8Unorm' => (0x00000058, 'WGPUTextureFormat_ASTC10x8Unorm'));
  __PACKAGE__->_add_enum('ASTC10x8UnormSrgb' => (0x00000059, 'WGPUTextureFormat_ASTC10x8UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC10x10Unorm' => (0x0000005A, 'WGPUTextureFormat_ASTC10x10Unorm'));
  __PACKAGE__->_add_enum('ASTC10x10UnormSrgb' => (0x0000005B, 'WGPUTextureFormat_ASTC10x10UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC12x10Unorm' => (0x0000005C, 'WGPUTextureFormat_ASTC12x10Unorm'));
  __PACKAGE__->_add_enum('ASTC12x10UnormSrgb' => (0x0000005D, 'WGPUTextureFormat_ASTC12x10UnormSrgb'));
  __PACKAGE__->_add_enum('ASTC12x12Unorm' => (0x0000005E, 'WGPUTextureFormat_ASTC12x12Unorm'));
  __PACKAGE__->_add_enum('ASTC12x12UnormSrgb' => (0x0000005F, 'WGPUTextureFormat_ASTC12x12UnormSrgb'));
  WebGPU::Direct::TextureFormat->_build_const_lut;
};

package
	WebGPU::Direct::TextureSampleType {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('bindingNotUsed' => (0x00000000, 'WGPUTextureSampleType_BindingNotUsed'));
  __PACKAGE__->_add_enum('undefined' => (0x00000001, 'WGPUTextureSampleType_Undefined'));
  __PACKAGE__->_add_enum('float' => (0x00000002, 'WGPUTextureSampleType_Float'));
  __PACKAGE__->_add_enum('unfilterableFloat' => (0x00000003, 'WGPUTextureSampleType_UnfilterableFloat'));
  __PACKAGE__->_add_enum('depth' => (0x00000004, 'WGPUTextureSampleType_Depth'));
  __PACKAGE__->_add_enum('sint' => (0x00000005, 'WGPUTextureSampleType_Sint'));
  __PACKAGE__->_add_enum('uint' => (0x00000006, 'WGPUTextureSampleType_Uint'));
  WebGPU::Direct::TextureSampleType->_build_const_lut;
};

package
	WebGPU::Direct::TextureUsage {
  use base "WebGPU::Direct::Flag";
  __PACKAGE__->_add_enum('none' => (0x0000000000000000, 'WGPUTextureUsage_None'));
  __PACKAGE__->_add_enum('copySrc' => (0x0000000000000001, 'WGPUTextureUsage_CopySrc'));
  __PACKAGE__->_add_enum('copyDst' => (0x0000000000000002, 'WGPUTextureUsage_CopyDst'));
  __PACKAGE__->_add_enum('textureBinding' => (0x0000000000000004, 'WGPUTextureUsage_TextureBinding'));
  __PACKAGE__->_add_enum('storageBinding' => (0x0000000000000008, 'WGPUTextureUsage_StorageBinding'));
  __PACKAGE__->_add_enum('renderAttachment' => (0x0000000000000010, 'WGPUTextureUsage_RenderAttachment'));
  WebGPU::Direct::TextureUsage->_build_const_lut;
};

package
	WebGPU::Direct::TextureViewDimension {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('undefined' => (0x00000000, 'WGPUTextureViewDimension_Undefined'));
  __PACKAGE__->_add_enum('_1D' => (0x00000001, 'WGPUTextureViewDimension_1D'));
  __PACKAGE__->_add_enum('_2D' => (0x00000002, 'WGPUTextureViewDimension_2D'));
  __PACKAGE__->_add_enum('_2DArray' => (0x00000003, 'WGPUTextureViewDimension_2DArray'));
  __PACKAGE__->_add_enum('cube' => (0x00000004, 'WGPUTextureViewDimension_Cube'));
  __PACKAGE__->_add_enum('cubeArray' => (0x00000005, 'WGPUTextureViewDimension_CubeArray'));
  __PACKAGE__->_add_enum('_3D' => (0x00000006, 'WGPUTextureViewDimension_3D'));
  WebGPU::Direct::TextureViewDimension->_build_const_lut;
};

package
	WebGPU::Direct::VertexFormat {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('uint8' => (0x00000001, 'WGPUVertexFormat_Uint8'));
  __PACKAGE__->_add_enum('uint8x2' => (0x00000002, 'WGPUVertexFormat_Uint8x2'));
  __PACKAGE__->_add_enum('uint8x4' => (0x00000003, 'WGPUVertexFormat_Uint8x4'));
  __PACKAGE__->_add_enum('sint8' => (0x00000004, 'WGPUVertexFormat_Sint8'));
  __PACKAGE__->_add_enum('sint8x2' => (0x00000005, 'WGPUVertexFormat_Sint8x2'));
  __PACKAGE__->_add_enum('sint8x4' => (0x00000006, 'WGPUVertexFormat_Sint8x4'));
  __PACKAGE__->_add_enum('unorm8' => (0x00000007, 'WGPUVertexFormat_Unorm8'));
  __PACKAGE__->_add_enum('unorm8x2' => (0x00000008, 'WGPUVertexFormat_Unorm8x2'));
  __PACKAGE__->_add_enum('unorm8x4' => (0x00000009, 'WGPUVertexFormat_Unorm8x4'));
  __PACKAGE__->_add_enum('snorm8' => (0x0000000A, 'WGPUVertexFormat_Snorm8'));
  __PACKAGE__->_add_enum('snorm8x2' => (0x0000000B, 'WGPUVertexFormat_Snorm8x2'));
  __PACKAGE__->_add_enum('snorm8x4' => (0x0000000C, 'WGPUVertexFormat_Snorm8x4'));
  __PACKAGE__->_add_enum('uint16' => (0x0000000D, 'WGPUVertexFormat_Uint16'));
  __PACKAGE__->_add_enum('uint16x2' => (0x0000000E, 'WGPUVertexFormat_Uint16x2'));
  __PACKAGE__->_add_enum('uint16x4' => (0x0000000F, 'WGPUVertexFormat_Uint16x4'));
  __PACKAGE__->_add_enum('sint16' => (0x00000010, 'WGPUVertexFormat_Sint16'));
  __PACKAGE__->_add_enum('sint16x2' => (0x00000011, 'WGPUVertexFormat_Sint16x2'));
  __PACKAGE__->_add_enum('sint16x4' => (0x00000012, 'WGPUVertexFormat_Sint16x4'));
  __PACKAGE__->_add_enum('unorm16' => (0x00000013, 'WGPUVertexFormat_Unorm16'));
  __PACKAGE__->_add_enum('unorm16x2' => (0x00000014, 'WGPUVertexFormat_Unorm16x2'));
  __PACKAGE__->_add_enum('unorm16x4' => (0x00000015, 'WGPUVertexFormat_Unorm16x4'));
  __PACKAGE__->_add_enum('snorm16' => (0x00000016, 'WGPUVertexFormat_Snorm16'));
  __PACKAGE__->_add_enum('snorm16x2' => (0x00000017, 'WGPUVertexFormat_Snorm16x2'));
  __PACKAGE__->_add_enum('snorm16x4' => (0x00000018, 'WGPUVertexFormat_Snorm16x4'));
  __PACKAGE__->_add_enum('float16' => (0x00000019, 'WGPUVertexFormat_Float16'));
  __PACKAGE__->_add_enum('float16x2' => (0x0000001A, 'WGPUVertexFormat_Float16x2'));
  __PACKAGE__->_add_enum('float16x4' => (0x0000001B, 'WGPUVertexFormat_Float16x4'));
  __PACKAGE__->_add_enum('float32' => (0x0000001C, 'WGPUVertexFormat_Float32'));
  __PACKAGE__->_add_enum('float32x2' => (0x0000001D, 'WGPUVertexFormat_Float32x2'));
  __PACKAGE__->_add_enum('float32x3' => (0x0000001E, 'WGPUVertexFormat_Float32x3'));
  __PACKAGE__->_add_enum('float32x4' => (0x0000001F, 'WGPUVertexFormat_Float32x4'));
  __PACKAGE__->_add_enum('uint32' => (0x00000020, 'WGPUVertexFormat_Uint32'));
  __PACKAGE__->_add_enum('uint32x2' => (0x00000021, 'WGPUVertexFormat_Uint32x2'));
  __PACKAGE__->_add_enum('uint32x3' => (0x00000022, 'WGPUVertexFormat_Uint32x3'));
  __PACKAGE__->_add_enum('uint32x4' => (0x00000023, 'WGPUVertexFormat_Uint32x4'));
  __PACKAGE__->_add_enum('sint32' => (0x00000024, 'WGPUVertexFormat_Sint32'));
  __PACKAGE__->_add_enum('sint32x2' => (0x00000025, 'WGPUVertexFormat_Sint32x2'));
  __PACKAGE__->_add_enum('sint32x3' => (0x00000026, 'WGPUVertexFormat_Sint32x3'));
  __PACKAGE__->_add_enum('sint32x4' => (0x00000027, 'WGPUVertexFormat_Sint32x4'));
  __PACKAGE__->_add_enum('unorm10_10_10_2' => (0x00000028, 'WGPUVertexFormat_Unorm10_10_10_2'));
  __PACKAGE__->_add_enum('unorm8x4BGRA' => (0x00000029, 'WGPUVertexFormat_Unorm8x4BGRA'));
  WebGPU::Direct::VertexFormat->_build_const_lut;
};

package
	WebGPU::Direct::VertexStepMode {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('vertexBufferNotUsed' => (0x00000000, 'WGPUVertexStepMode_VertexBufferNotUsed'));
  __PACKAGE__->_add_enum('undefined' => (0x00000001, 'WGPUVertexStepMode_Undefined'));
  __PACKAGE__->_add_enum('vertex' => (0x00000002, 'WGPUVertexStepMode_Vertex'));
  __PACKAGE__->_add_enum('instance' => (0x00000003, 'WGPUVertexStepMode_Instance'));
  WebGPU::Direct::VertexStepMode->_build_const_lut;
};

package
	WebGPU::Direct::WGSLLanguageFeatureName {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('readonlyAndReadwriteStorageTextures' => (0x00000001, 'WGPUWGSLLanguageFeatureName_ReadonlyAndReadwriteStorageTextures'));
  __PACKAGE__->_add_enum('packed4x8IntegerDotProduct' => (0x00000002, 'WGPUWGSLLanguageFeatureName_Packed4x8IntegerDotProduct'));
  __PACKAGE__->_add_enum('unrestrictedPointerParameters' => (0x00000003, 'WGPUWGSLLanguageFeatureName_UnrestrictedPointerParameters'));
  __PACKAGE__->_add_enum('pointerCompositeAccess' => (0x00000004, 'WGPUWGSLLanguageFeatureName_PointerCompositeAccess'));
  WebGPU::Direct::WGSLLanguageFeatureName->_build_const_lut;
};

package
	WebGPU::Direct::WaitStatus {
  use base "WebGPU::Direct::Enum";
  __PACKAGE__->_add_enum('success' => (0x00000001, 'WGPUWaitStatus_Success'));
  __PACKAGE__->_add_enum('timedOut' => (0x00000002, 'WGPUWaitStatus_TimedOut'));
  __PACKAGE__->_add_enum('unsupportedTimeout' => (0x00000003, 'WGPUWaitStatus_UnsupportedTimeout'));
  __PACKAGE__->_add_enum('unsupportedCount' => (0x00000004, 'WGPUWaitStatus_UnsupportedCount'));
  __PACKAGE__->_add_enum('unsupportedMixedSources' => (0x00000005, 'WGPUWaitStatus_UnsupportedMixedSources'));
  WebGPU::Direct::WaitStatus->_build_const_lut;
};

package
	WebGPU::Direct::StringView {
    
    require WebGPU::Direct::StringView;
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::StringView\n"
          if !$class->isa("WebGPU::Direct::StringView");
        $class = ref($class) ? ref($class) : $class;
        my %params = (scalar @_ == 1 && ref( $_[0] ) eq '') ? (data => $_[0]) : ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::Adapter {
    push @WebGPU::Direct::Adapter::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Adapter;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::BindGroup {
    push @WebGPU::Direct::BindGroup::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::BindGroup;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::BindGroupLayout {
    push @WebGPU::Direct::BindGroupLayout::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::BindGroupLayout;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Buffer {
    push @WebGPU::Direct::Buffer::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Buffer;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::CommandBuffer {
    push @WebGPU::Direct::CommandBuffer::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::CommandBuffer;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::CommandEncoder {
    push @WebGPU::Direct::CommandEncoder::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::CommandEncoder;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::ComputePassEncoder {
    push @WebGPU::Direct::ComputePassEncoder::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::ComputePassEncoder;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::ComputePipeline {
    push @WebGPU::Direct::ComputePipeline::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::ComputePipeline;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Device {
    push @WebGPU::Direct::Device::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Device;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Instance {
    push @WebGPU::Direct::Instance::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Instance;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::PipelineLayout {
    push @WebGPU::Direct::PipelineLayout::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::PipelineLayout;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::QuerySet {
    push @WebGPU::Direct::QuerySet::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::QuerySet;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Queue {
    push @WebGPU::Direct::Queue::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Queue;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::RenderBundle {
    push @WebGPU::Direct::RenderBundle::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::RenderBundle;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::RenderBundleEncoder {
    push @WebGPU::Direct::RenderBundleEncoder::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::RenderBundleEncoder;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::RenderPassEncoder {
    push @WebGPU::Direct::RenderPassEncoder::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::RenderPassEncoder;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::RenderPipeline {
    push @WebGPU::Direct::RenderPipeline::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::RenderPipeline;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Sampler {
    push @WebGPU::Direct::Sampler::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Sampler;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::ShaderModule {
    push @WebGPU::Direct::ShaderModule::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::ShaderModule;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Surface {
    push @WebGPU::Direct::Surface::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Surface;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::Texture {
    push @WebGPU::Direct::Texture::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::Texture;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::TextureView {
    push @WebGPU::Direct::TextureView::ISA, "WebGPU::Direct::Opaque";
    require WebGPU::Direct::TextureView;
    sub new {
        local $SIG{__DIE__} = \&Carp::croak;
        my $class = __PACKAGE__;
        die "Cannot call new on abstract class $class";
    }
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->release;
      }
    }

}

package
	WebGPU::Direct::ChainedStruct {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ChainedStruct\n"
          if !$class->isa("WebGPU::Direct::ChainedStruct");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ChainedStructOut {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ChainedStructOut\n"
          if !$class->isa("WebGPU::Direct::ChainedStructOut");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BufferMapCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BufferMapCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::BufferMapCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CompilationInfoCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CompilationInfoCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::CompilationInfoCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CreateComputePipelineAsyncCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CreateComputePipelineAsyncCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::CreateComputePipelineAsyncCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CreateRenderPipelineAsyncCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CreateRenderPipelineAsyncCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::CreateRenderPipelineAsyncCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::DeviceLostCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::DeviceLostCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::DeviceLostCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::PopErrorScopeCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::PopErrorScopeCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::PopErrorScopeCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::QueueWorkDoneCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::QueueWorkDoneCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::QueueWorkDoneCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RequestAdapterCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RequestAdapterCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::RequestAdapterCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RequestDeviceCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RequestDeviceCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::RequestDeviceCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::UncapturedErrorCallbackInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::UncapturedErrorCallbackInfo\n"
          if !$class->isa("WebGPU::Direct::UncapturedErrorCallbackInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::AdapterInfo {
    
    require WebGPU::Direct::AdapterInfo;
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::AdapterInfo\n"
          if !$class->isa("WebGPU::Direct::AdapterInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->freeMembers;
      }
    }

}

package
	WebGPU::Direct::BindGroupEntry {
    
    require WebGPU::Direct::BindGroupEntry;
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BindGroupEntry\n"
          if !$class->isa("WebGPU::Direct::BindGroupEntry");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BlendComponent {
    
    my $default = {
             'dstFactor' => WebGPU::Direct::BlendFactor->zero,
             'operation' => WebGPU::Direct::BlendOperation->add,
             'srcFactor' => WebGPU::Direct::BlendFactor->one,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BlendComponent\n"
          if !$class->isa("WebGPU::Direct::BlendComponent");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BufferBindingLayout {
    
    my $default = {
             'hasDynamicOffset' => 0,
             'minBindingSize' => 0,
             'type' => WebGPU::Direct::BufferBindingType->uniform,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BufferBindingLayout\n"
          if !$class->isa("WebGPU::Direct::BufferBindingLayout");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BufferDescriptor {
    
    my $default = {
             'mappedAtCreation' => 0,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BufferDescriptor\n"
          if !$class->isa("WebGPU::Direct::BufferDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::Color {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::Color\n"
          if !$class->isa("WebGPU::Direct::Color");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref [] ? (r => $_[0]->[0] // 0, g => $_[0]->[1] // 0, b => $_[0]->[2] // 0, a => $_[0]->[3] // 0) : ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CommandBufferDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CommandBufferDescriptor\n"
          if !$class->isa("WebGPU::Direct::CommandBufferDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CommandEncoderDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CommandEncoderDescriptor\n"
          if !$class->isa("WebGPU::Direct::CommandEncoderDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CompilationMessage {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CompilationMessage\n"
          if !$class->isa("WebGPU::Direct::CompilationMessage");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ComputePassTimestampWrites {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ComputePassTimestampWrites\n"
          if !$class->isa("WebGPU::Direct::ComputePassTimestampWrites");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ConstantEntry {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ConstantEntry\n"
          if !$class->isa("WebGPU::Direct::ConstantEntry");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::Extent3D {
    
    my $default = {
             'depthOrArrayLayers' => 1,
             'height' => 1,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::Extent3D\n"
          if !$class->isa("WebGPU::Direct::Extent3D");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref [] ? (width => $_[0]->[0] // 0, height => $_[0]->[1] // 1, depthOrArrayLayers => $_[0]->[2] // 1) : ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::Future {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::Future\n"
          if !$class->isa("WebGPU::Direct::Future");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::InstanceCapabilities {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::InstanceCapabilities\n"
          if !$class->isa("WebGPU::Direct::InstanceCapabilities");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::Limits {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::Limits\n"
          if !$class->isa("WebGPU::Direct::Limits");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::MultisampleState {
    
    my $default = {
             'alphaToCoverageEnabled' => 0,
             'count' => 1,
             'mask' => 4294967295,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::MultisampleState\n"
          if !$class->isa("WebGPU::Direct::MultisampleState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::Origin3D {
    
    my $default = {
             'x' => 0,
             'y' => 0,
             'z' => 0,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::Origin3D\n"
          if !$class->isa("WebGPU::Direct::Origin3D");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::PipelineLayoutDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::PipelineLayoutDescriptor\n"
          if !$class->isa("WebGPU::Direct::PipelineLayoutDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::PrimitiveState {
    
    my $default = {
             'cullMode' => WebGPU::Direct::CullMode->none,
             'frontFace' => WebGPU::Direct::FrontFace->CCW,
             'topology' => WebGPU::Direct::PrimitiveTopology->triangleList,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::PrimitiveState\n"
          if !$class->isa("WebGPU::Direct::PrimitiveState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::QuerySetDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::QuerySetDescriptor\n"
          if !$class->isa("WebGPU::Direct::QuerySetDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::QueueDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::QueueDescriptor\n"
          if !$class->isa("WebGPU::Direct::QueueDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderBundleDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderBundleDescriptor\n"
          if !$class->isa("WebGPU::Direct::RenderBundleDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderBundleEncoderDescriptor {
    
    my $default = {
             'depthReadOnly' => 0,
             'sampleCount' => 1,
             'stencilReadOnly' => 0,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderBundleEncoderDescriptor\n"
          if !$class->isa("WebGPU::Direct::RenderBundleEncoderDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderPassDepthStencilAttachment {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderPassDepthStencilAttachment\n"
          if !$class->isa("WebGPU::Direct::RenderPassDepthStencilAttachment");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderPassMaxDrawCount {
    push @WebGPU::Direct::RenderPassMaxDrawCount::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderPassMaxDrawCount\n"
          if !$class->isa("WebGPU::Direct::RenderPassMaxDrawCount");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderPassTimestampWrites {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderPassTimestampWrites\n"
          if !$class->isa("WebGPU::Direct::RenderPassTimestampWrites");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RequestAdapterOptions {
    
    my $default = {
             'forceFallbackAdapter' => 0,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RequestAdapterOptions\n"
          if !$class->isa("WebGPU::Direct::RequestAdapterOptions");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SamplerBindingLayout {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SamplerBindingLayout\n"
          if !$class->isa("WebGPU::Direct::SamplerBindingLayout");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SamplerDescriptor {
    
    my $default = {
             'addressModeU' => WebGPU::Direct::AddressMode->clampToEdge,
             'addressModeV' => WebGPU::Direct::AddressMode->clampToEdge,
             'addressModeW' => WebGPU::Direct::AddressMode->clampToEdge,
             'lodMaxClamp' => 32,
             'lodMinClamp' => 0,
             'magFilter' => WebGPU::Direct::FilterMode->nearest,
             'maxAnisotropy' => 1,
             'minFilter' => WebGPU::Direct::FilterMode->nearest,
             'mipmapFilter' => WebGPU::Direct::MipmapFilterMode->nearest,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SamplerDescriptor\n"
          if !$class->isa("WebGPU::Direct::SamplerDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ShaderModuleDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ShaderModuleDescriptor\n"
          if !$class->isa("WebGPU::Direct::ShaderModuleDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ShaderSourceSPIRV {
    push @WebGPU::Direct::ShaderSourceSPIRV::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ShaderSourceSPIRV\n"
          if !$class->isa("WebGPU::Direct::ShaderSourceSPIRV");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ShaderSourceWGSL {
    push @WebGPU::Direct::ShaderSourceWGSL::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ShaderSourceWGSL\n"
          if !$class->isa("WebGPU::Direct::ShaderSourceWGSL");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::StencilFaceState {
    
    my $default = {
             'compare' => WebGPU::Direct::CompareFunction->always,
             'depthFailOp' => WebGPU::Direct::StencilOperation->keep,
             'failOp' => WebGPU::Direct::StencilOperation->keep,
             'passOp' => WebGPU::Direct::StencilOperation->keep,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::StencilFaceState\n"
          if !$class->isa("WebGPU::Direct::StencilFaceState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::StorageTextureBindingLayout {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::StorageTextureBindingLayout\n"
          if !$class->isa("WebGPU::Direct::StorageTextureBindingLayout");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SupportedFeatures {
    
    require WebGPU::Direct::SupportedFeatures;
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SupportedFeatures\n"
          if !$class->isa("WebGPU::Direct::SupportedFeatures");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->freeMembers;
      }
    }

}

package
	WebGPU::Direct::SupportedWGSLLanguageFeatures {
    
    require WebGPU::Direct::SupportedWGSLLanguageFeatures;
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SupportedWGSLLanguageFeatures\n"
          if !$class->isa("WebGPU::Direct::SupportedWGSLLanguageFeatures");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->freeMembers;
      }
    }

}

package
	WebGPU::Direct::SurfaceCapabilities {
    
    require WebGPU::Direct::SurfaceCapabilities;
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceCapabilities\n"
          if !$class->isa("WebGPU::Direct::SurfaceCapabilities");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
    sub DESTROY
    {
      if ( ${^GLOBAL_PHASE} ne 'DESTRUCT' )
      {
        $_[0]->freeMembers;
      }
    }

}

package
	WebGPU::Direct::SurfaceConfiguration {
    
    my $default = {
             'alphaMode' => WebGPU::Direct::CompositeAlphaMode->auto,
             'usage' => WebGPU::Direct::TextureUsage->renderAttachment,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceConfiguration\n"
          if !$class->isa("WebGPU::Direct::SurfaceConfiguration");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceDescriptor\n"
          if !$class->isa("WebGPU::Direct::SurfaceDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceSourceAndroidNativeWindow {
    push @WebGPU::Direct::SurfaceSourceAndroidNativeWindow::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceSourceAndroidNativeWindow\n"
          if !$class->isa("WebGPU::Direct::SurfaceSourceAndroidNativeWindow");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceSourceMetalLayer {
    push @WebGPU::Direct::SurfaceSourceMetalLayer::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceSourceMetalLayer\n"
          if !$class->isa("WebGPU::Direct::SurfaceSourceMetalLayer");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceSourceWaylandSurface {
    push @WebGPU::Direct::SurfaceSourceWaylandSurface::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceSourceWaylandSurface\n"
          if !$class->isa("WebGPU::Direct::SurfaceSourceWaylandSurface");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceSourceWindowsHWND {
    push @WebGPU::Direct::SurfaceSourceWindowsHWND::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceSourceWindowsHWND\n"
          if !$class->isa("WebGPU::Direct::SurfaceSourceWindowsHWND");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceSourceXCBWindow {
    push @WebGPU::Direct::SurfaceSourceXCBWindow::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceSourceXCBWindow\n"
          if !$class->isa("WebGPU::Direct::SurfaceSourceXCBWindow");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceSourceXlibWindow {
    push @WebGPU::Direct::SurfaceSourceXlibWindow::ISA, "WebGPU::Direct::ChainedStruct";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceSourceXlibWindow\n"
          if !$class->isa("WebGPU::Direct::SurfaceSourceXlibWindow");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::SurfaceTexture {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::SurfaceTexture\n"
          if !$class->isa("WebGPU::Direct::SurfaceTexture");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::TexelCopyBufferLayout {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::TexelCopyBufferLayout\n"
          if !$class->isa("WebGPU::Direct::TexelCopyBufferLayout");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::TextureBindingLayout {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::TextureBindingLayout\n"
          if !$class->isa("WebGPU::Direct::TextureBindingLayout");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::TextureViewDescriptor {
    
    my $default = {
             'aspect' => WebGPU::Direct::TextureAspect->all,
             'baseArrayLayer' => 0,
             'baseMipLevel' => 0,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::TextureViewDescriptor\n"
          if !$class->isa("WebGPU::Direct::TextureViewDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::VertexAttribute {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::VertexAttribute\n"
          if !$class->isa("WebGPU::Direct::VertexAttribute");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BindGroupDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BindGroupDescriptor\n"
          if !$class->isa("WebGPU::Direct::BindGroupDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BindGroupLayoutEntry {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BindGroupLayoutEntry\n"
          if !$class->isa("WebGPU::Direct::BindGroupLayoutEntry");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BlendState {
    push @WebGPU::Direct::BlendState::ISA, "WebGPU::Direct::BlendComponent";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BlendState\n"
          if !$class->isa("WebGPU::Direct::BlendState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::CompilationInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::CompilationInfo\n"
          if !$class->isa("WebGPU::Direct::CompilationInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ComputePassDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ComputePassDescriptor\n"
          if !$class->isa("WebGPU::Direct::ComputePassDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::DepthStencilState {
    
    my $default = {
             'depthBias' => 0,
             'depthBiasClamp' => 0,
             'depthBiasSlopeScale' => 0,
             'stencilReadMask' => 4294967295,
             'stencilWriteMask' => 4294967295,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::DepthStencilState\n"
          if !$class->isa("WebGPU::Direct::DepthStencilState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::DeviceDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::DeviceDescriptor\n"
          if !$class->isa("WebGPU::Direct::DeviceDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::FutureWaitInfo {
    push @WebGPU::Direct::FutureWaitInfo::ISA, "WebGPU::Direct::Future";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::FutureWaitInfo\n"
          if !$class->isa("WebGPU::Direct::FutureWaitInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::InstanceDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::InstanceDescriptor\n"
          if !$class->isa("WebGPU::Direct::InstanceDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ProgrammableStageDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ProgrammableStageDescriptor\n"
          if !$class->isa("WebGPU::Direct::ProgrammableStageDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderPassColorAttachment {
    
    my $default = {
             'depthSlice' => -1,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderPassColorAttachment\n"
          if !$class->isa("WebGPU::Direct::RenderPassColorAttachment");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::TexelCopyBufferInfo {
    push @WebGPU::Direct::TexelCopyBufferInfo::ISA, "WebGPU::Direct::TexelCopyBufferLayout";
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::TexelCopyBufferInfo\n"
          if !$class->isa("WebGPU::Direct::TexelCopyBufferInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::TexelCopyTextureInfo {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::TexelCopyTextureInfo\n"
          if !$class->isa("WebGPU::Direct::TexelCopyTextureInfo");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::TextureDescriptor {
    
    my $default = {
             'dimension' => WebGPU::Direct::TextureDimension->_2D,
             'mipLevelCount' => 1,
             'sampleCount' => 1,
             'size' => {
                         'depthOrArrayLayers' => 1,
                         'height' => 1,
                       },
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::TextureDescriptor\n"
          if !$class->isa("WebGPU::Direct::TextureDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::VertexBufferLayout {
    
    my $default = {
             'stepMode' => WebGPU::Direct::VertexStepMode->vertex,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::VertexBufferLayout\n"
          if !$class->isa("WebGPU::Direct::VertexBufferLayout");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::BindGroupLayoutDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::BindGroupLayoutDescriptor\n"
          if !$class->isa("WebGPU::Direct::BindGroupLayoutDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ColorTargetState {
    
    my $default = {
             'blend' => undef,
             'writeMask' => WebGPU::Direct::ColorWriteMask->all,
           };

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ColorTargetState\n"
          if !$class->isa("WebGPU::Direct::ColorTargetState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::ComputePipelineDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::ComputePipelineDescriptor\n"
          if !$class->isa("WebGPU::Direct::ComputePipelineDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderPassDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderPassDescriptor\n"
          if !$class->isa("WebGPU::Direct::RenderPassDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::VertexState {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::VertexState\n"
          if !$class->isa("WebGPU::Direct::VertexState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::FragmentState {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::FragmentState\n"
          if !$class->isa("WebGPU::Direct::FragmentState");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

package
	WebGPU::Direct::RenderPipelineDescriptor {
    
    my $default = {};

    sub new {
        local $SIG{__DIE__} = \&Carp::confess;
        my $class = shift;
        die "$class does not inherit from WebGPU::Direct::RenderPipelineDescriptor\n"
          if !$class->isa("WebGPU::Direct::RenderPipelineDescriptor");
        $class = ref($class) ? ref($class) : $class;
        my %params = ref( $_[0] ) eq ref {} ? %{$_[0]} : @_;
        my $result = { %$default, %params };
        $result = $class->BUILDARGS($result)
          if $class->can('BUILDARGS');
        $result = bless( $result, $class );
        $result->pack;
        return $result;
    }
    
}

1;
