react-native-webgpu 0.5.11 → 0.5.13

package/cpp/webgpu/webgpu_cpp.h

@@ -163,6 +163,44 @@ enum class CallbackMode : uint32_t {
 static_assert(sizeof(CallbackMode) == sizeof(WGPUCallbackMode), "sizeof mismatch for CallbackMode");
 static_assert(alignof(CallbackMode) == alignof(WGPUCallbackMode), "alignof mismatch for CallbackMode");
 
+enum class ColorSpacePrimariesDawn : uint32_t {
+    SRGB = WGPUColorSpacePrimariesDawn_SRGB,
+    Rec709 = WGPUColorSpacePrimariesDawn_Rec709,
+    Rec601 = WGPUColorSpacePrimariesDawn_Rec601,
+    Rec2020 = WGPUColorSpacePrimariesDawn_Rec2020,
+    DisplayP3 = WGPUColorSpacePrimariesDawn_DisplayP3,
+};
+static_assert(sizeof(ColorSpacePrimariesDawn) == sizeof(WGPUColorSpacePrimariesDawn), "sizeof mismatch for ColorSpacePrimariesDawn");
+static_assert(alignof(ColorSpacePrimariesDawn) == alignof(WGPUColorSpacePrimariesDawn), "alignof mismatch for ColorSpacePrimariesDawn");
+
+enum class ColorSpaceTransferDawn : uint32_t {
+    Identity = WGPUColorSpaceTransferDawn_Identity,
+    SRGB = WGPUColorSpaceTransferDawn_SRGB,
+    DisplayP3 = WGPUColorSpaceTransferDawn_DisplayP3,
+    SMPTE_170M = WGPUColorSpaceTransferDawn_SMPTE_170M,
+    HLG = WGPUColorSpaceTransferDawn_HLG,
+    PQ = WGPUColorSpaceTransferDawn_PQ,
+};
+static_assert(sizeof(ColorSpaceTransferDawn) == sizeof(WGPUColorSpaceTransferDawn), "sizeof mismatch for ColorSpaceTransferDawn");
+static_assert(alignof(ColorSpaceTransferDawn) == alignof(WGPUColorSpaceTransferDawn), "alignof mismatch for ColorSpaceTransferDawn");
+
+enum class ColorSpaceYCbCrMatrixDawn : uint32_t {
+    Identity = WGPUColorSpaceYCbCrMatrixDawn_Identity,
+    Rec601 = WGPUColorSpaceYCbCrMatrixDawn_Rec601,
+    Rec709 = WGPUColorSpaceYCbCrMatrixDawn_Rec709,
+    Rec2020 = WGPUColorSpaceYCbCrMatrixDawn_Rec2020,
+};
+static_assert(sizeof(ColorSpaceYCbCrMatrixDawn) == sizeof(WGPUColorSpaceYCbCrMatrixDawn), "sizeof mismatch for ColorSpaceYCbCrMatrixDawn");
+static_assert(alignof(ColorSpaceYCbCrMatrixDawn) == alignof(WGPUColorSpaceYCbCrMatrixDawn), "alignof mismatch for ColorSpaceYCbCrMatrixDawn");
+
+enum class ColorSpaceYCbCrRangeDawn : uint32_t {
+    Identity = WGPUColorSpaceYCbCrRangeDawn_Identity,
+    Narrow = WGPUColorSpaceYCbCrRangeDawn_Narrow,
+    Full = WGPUColorSpaceYCbCrRangeDawn_Full,
+};
+static_assert(sizeof(ColorSpaceYCbCrRangeDawn) == sizeof(WGPUColorSpaceYCbCrRangeDawn), "sizeof mismatch for ColorSpaceYCbCrRangeDawn");
+static_assert(alignof(ColorSpaceYCbCrRangeDawn) == alignof(WGPUColorSpaceYCbCrRangeDawn), "alignof mismatch for ColorSpaceYCbCrRangeDawn");
+
 enum class CompareFunction : uint32_t {
     Undefined = WGPUCompareFunction_Undefined,
     Never = WGPUCompareFunction_Never,
@@ -357,12 +395,13 @@ enum class FeatureName : uint32_t {
     SharedBufferMemoryD3D12SharedMemoryFileMappingHandle = WGPUFeatureName_SharedBufferMemoryD3D12SharedMemoryFileMappingHandle,
     SharedTextureMemoryD3D12Resource = WGPUFeatureName_SharedTextureMemoryD3D12Resource,
     ChromiumExperimentalSamplingResourceTable = WGPUFeatureName_ChromiumExperimentalSamplingResourceTable,
-    ChromiumExperimentalSubgroupSizeControl = WGPUFeatureName_ChromiumExperimentalSubgroupSizeControl,
+    SubgroupSizeControl = WGPUFeatureName_SubgroupSizeControl,
     AtomicVec2uMinMax = WGPUFeatureName_AtomicVec2uMinMax,
     Unorm16FormatsForExternalTexture = WGPUFeatureName_Unorm16FormatsForExternalTexture,
     OpaqueYCbCrAndroidForExternalTexture = WGPUFeatureName_OpaqueYCbCrAndroidForExternalTexture,
     Unorm16Filterable = WGPUFeatureName_Unorm16Filterable,
     RenderPassRenderArea = WGPUFeatureName_RenderPassRenderArea,
+    AdapterPropertiesDrm = WGPUFeatureName_AdapterPropertiesDrm,
 };
 static_assert(sizeof(FeatureName) == sizeof(WGPUFeatureName), "sizeof mismatch for FeatureName");
 static_assert(alignof(FeatureName) == alignof(WGPUFeatureName), "alignof mismatch for FeatureName");
@@ -453,6 +492,8 @@ static_assert(alignof(PowerPreference) == alignof(WGPUPowerPreference), "alignof
 enum class PredefinedColorSpace : uint32_t {
     SRGB = WGPUPredefinedColorSpace_SRGB,
     DisplayP3 = WGPUPredefinedColorSpace_DisplayP3,
+    SRGBLinear = WGPUPredefinedColorSpace_SRGBLinear,
+    DisplayP3Linear = WGPUPredefinedColorSpace_DisplayP3Linear,
 };
 static_assert(sizeof(PredefinedColorSpace) == sizeof(WGPUPredefinedColorSpace), "sizeof mismatch for PredefinedColorSpace");
 static_assert(alignof(PredefinedColorSpace) == alignof(WGPUPredefinedColorSpace), "alignof mismatch for PredefinedColorSpace");
@@ -666,7 +707,7 @@ enum class SType : uint32_t {
     SharedTextureMemoryD3D12ResourceDescriptor = WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor,
     RequestAdapterOptionsAngleVirtualizationGroup = WGPUSType_RequestAdapterOptionsAngleVirtualizationGroup,
     PipelineLayoutResourceTable = WGPUSType_PipelineLayoutResourceTable,
-    AdapterPropertiesExplicitComputeSubgroupSizeConfigs = WGPUSType_AdapterPropertiesExplicitComputeSubgroupSizeConfigs,
+    AdapterPropertiesDrm = WGPUSType_AdapterPropertiesDrm,
 };
 static_assert(sizeof(SType) == sizeof(WGPUSType), "sizeof mismatch for SType");
 static_assert(alignof(SType) == alignof(WGPUSType), "alignof mismatch for SType");
@@ -940,6 +981,7 @@ enum class WGSLLanguageFeatureName : uint32_t {
     TextureAndSamplerLet = WGPUWGSLLanguageFeatureName_TextureAndSamplerLet,
     SubgroupUniformity = WGPUWGSLLanguageFeatureName_SubgroupUniformity,
     TextureFormatsTier1 = WGPUWGSLLanguageFeatureName_TextureFormatsTier1,
+    LinearIndexing = WGPUWGSLLanguageFeatureName_LinearIndexing,
     ChromiumTestingUnimplemented = WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented,
     ChromiumTestingUnsafeExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental,
     ChromiumTestingExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental,
@@ -951,9 +993,7 @@ enum class WGSLLanguageFeatureName : uint32_t {
     FragmentDepth = WGPUWGSLLanguageFeatureName_FragmentDepth,
     ImmediateAddressSpace = WGPUWGSLLanguageFeatureName_ImmediateAddressSpace,
     BufferView = WGPUWGSLLanguageFeatureName_BufferView,
-    FilteringParameters = WGPUWGSLLanguageFeatureName_FilteringParameters,
     SwizzleAssignment = WGPUWGSLLanguageFeatureName_SwizzleAssignment,
-    LinearIndexing = WGPUWGSLLanguageFeatureName_LinearIndexing,
 };
 static_assert(sizeof(WGSLLanguageFeatureName) == sizeof(WGPUWGSLLanguageFeatureName), "sizeof mismatch for WGSLLanguageFeatureName");
 static_assert(alignof(WGSLLanguageFeatureName) == alignof(WGPUWGSLLanguageFeatureName), "alignof mismatch for WGSLLanguageFeatureName");
@@ -1235,7 +1275,7 @@ class RenderPassEncoder;
 
 struct StringView;
 struct AdapterPropertiesD3D;
-struct AdapterPropertiesExplicitComputeSubgroupSizeConfigs;
+struct AdapterPropertiesDrm;
 struct AdapterPropertiesVk;
 struct AdapterPropertiesWGPU;
 struct BindingResource;
@@ -1243,6 +1283,7 @@ struct BlendComponent;
 struct BufferBindingLayout;
 struct BufferHostMappedPointer;
 struct Color;
+struct ColorSpaceDawn;
 struct ColorTargetStateExpandResolveTextureDawn;
 struct CommandBufferDescriptor;
 struct CompatibilityModeLimits;
@@ -1545,8 +1586,6 @@ struct CallbackTypeBase<std::tuple<Args...>, T> {
     using Callback = void (Args..., T);
 };
 }  // namespace detail
-
-
 template <typename... T>
 using BufferMapCallback = typename detail::CallbackTypeBase<std::tuple<MapAsyncStatus, StringView>, T...>::Callback;
 template <typename... T>
@@ -1570,9 +1609,6 @@ using DeviceLostCallback = typename detail::CallbackTypeBase<std::tuple<const De
 template <typename... T>
 using UncapturedErrorCallback = typename detail::CallbackTypeBase<std::tuple<const Device&, ErrorType, StringView>, T...>::Callback;
 
-
-
-
 class Adapter : public ObjectBase<Adapter, WGPUAdapter> {
   public:
     using ObjectBase::ObjectBase;
@@ -1585,16 +1621,10 @@ class Adapter : public ObjectBase<Adapter, WGPUAdapter> {
     inline Instance GetInstance() const;
     inline ConvertibleStatus GetLimits(Limits * limits) const;
     inline Bool HasFeature(FeatureName feature) const;
-    template <typename F, typename T,
-              typename Cb = RequestDeviceCallback<T>,
-              typename CbChar = void (RequestDeviceStatus status, Device device, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = RequestDeviceCallback<>,
-              typename CbChar = std::function<void(RequestDeviceStatus status, Device device, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode, F callback) const;
 
 
   private:
@@ -1643,16 +1673,10 @@ class Buffer : public ObjectBase<Buffer, WGPUBuffer> {
     inline BufferMapState GetMapState() const;
     inline uint64_t GetSize() const;
     inline BufferUsage GetUsage() const;
-    template <typename F, typename T,
-              typename Cb = BufferMapCallback<T>,
-              typename CbChar = void (MapAsyncStatus status, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = BufferMapCallback<>,
-              typename CbChar = std::function<void(MapAsyncStatus status, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode, F callback) const;
     inline ConvertibleStatus ReadMappedRange(size_t offset, void * data, size_t size) const;
     inline void SetLabel(StringView label) const;
     inline void Unmap() const;
@@ -1733,16 +1757,10 @@ class Device : public ObjectBase<Device, WGPUDevice> {
     inline Buffer CreateBuffer(BufferDescriptor const * descriptor) const;
     inline CommandEncoder CreateCommandEncoder(CommandEncoderDescriptor const * descriptor = nullptr) const;
     inline ComputePipeline CreateComputePipeline(ComputePipelineDescriptor const * descriptor) const;
-    template <typename F, typename T,
-              typename Cb = CreateComputePipelineAsyncCallback<T>,
-              typename CbChar = void (CreatePipelineAsyncStatus status, ComputePipeline pipeline, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = CreateComputePipelineAsyncCallback<>,
-              typename CbChar = std::function<void(CreatePipelineAsyncStatus status, ComputePipeline pipeline, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback) const;
     inline Buffer CreateErrorBuffer(BufferDescriptor const * descriptor) const;
     inline ExternalTexture CreateErrorExternalTexture() const;
     inline ShaderModule CreateErrorShaderModule(ShaderModuleDescriptor const * descriptor, StringView errorMessage) const;
@@ -1752,16 +1770,10 @@ class Device : public ObjectBase<Device, WGPUDevice> {
     inline QuerySet CreateQuerySet(QuerySetDescriptor const * descriptor) const;
     inline RenderBundleEncoder CreateRenderBundleEncoder(RenderBundleEncoderDescriptor const * descriptor) const;
     inline RenderPipeline CreateRenderPipeline(RenderPipelineDescriptor const * descriptor) const;
-    template <typename F, typename T,
-              typename Cb = CreateRenderPipelineAsyncCallback<T>,
-              typename CbChar = void (CreatePipelineAsyncStatus status, RenderPipeline pipeline, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = CreateRenderPipelineAsyncCallback<>,
-              typename CbChar = std::function<void(CreatePipelineAsyncStatus status, RenderPipeline pipeline, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback) const;
     inline ResourceTable CreateResourceTable(ResourceTableDescriptor const * descriptor) const;
     inline Sampler CreateSampler(SamplerDescriptor const * descriptor = nullptr) const;
     inline ShaderModule CreateShaderModule(ShaderModuleDescriptor const * descriptor) const;
@@ -1780,28 +1792,16 @@ class Device : public ObjectBase<Device, WGPUDevice> {
     inline SharedFence ImportSharedFence(SharedFenceDescriptor const * descriptor) const;
     inline SharedTextureMemory ImportSharedTextureMemory(SharedTextureMemoryDescriptor const * descriptor) const;
     inline void InjectError(ErrorType type, StringView message) const;
-    template <typename F, typename T,
-              typename Cb = PopErrorScopeCallback<T>,
-              typename CbChar = void (PopErrorScopeStatus status, ErrorType type, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future PopErrorScope(CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = PopErrorScopeCallback<>,
-              typename CbChar = std::function<void(PopErrorScopeStatus status, ErrorType type, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future PopErrorScope(CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future PopErrorScope(CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future PopErrorScope(CallbackMode callbackMode, F callback) const;
     inline void PushErrorScope(ErrorFilter filter) const;
     inline void SetLabel(StringView label) const;
-    template <typename F, typename T,
-              typename Cb = LoggingCallback<T>,
-              typename CbChar = void (LoggingType type, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
+    template <typename F, typename T>
     void SetLoggingCallback(F callback, T userdata) const;
-    template <typename L,
-              typename Cb = LoggingCallback<>,
-              typename CbChar = std::function<void(LoggingType type, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    void SetLoggingCallback(L callback) const;
+    template <typename F>
+    void SetLoggingCallback(F callback) const;
     inline void Tick() const;
     inline void ValidateTextureDescriptor(TextureDescriptor const * descriptor) const;
 
@@ -1838,16 +1838,10 @@ class Instance : public ObjectBase<Instance, WGPUInstance> {
     inline void GetWGSLLanguageFeatures(SupportedWGSLLanguageFeatures * features) const;
     inline Bool HasWGSLLanguageFeature(WGSLLanguageFeatureName feature) const;
     inline void ProcessEvents() const;
-    template <typename F, typename T,
-              typename Cb = RequestAdapterCallback<T>,
-              typename CbChar = void (RequestAdapterStatus status, Adapter adapter, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = RequestAdapterCallback<>,
-              typename CbChar = std::function<void(RequestAdapterStatus status, Adapter adapter, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode, F callback) const;
     inline WaitStatus WaitAny(size_t futureCount, FutureWaitInfo * futures, uint64_t timeoutNS) const;
 
     inline WaitStatus WaitAny(Future f, uint64_t timeout) const;
@@ -1896,16 +1890,10 @@ class Queue : public ObjectBase<Queue, WGPUQueue> {
 
     inline void CopyExternalTextureForBrowser(ImageCopyExternalTexture const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const;
     inline void CopyTextureForBrowser(TexelCopyTextureInfo const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const;
-    template <typename F, typename T,
-              typename Cb = QueueWorkDoneCallback<T>,
-              typename CbChar = void (QueueWorkDoneStatus status, const char* message, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future OnSubmittedWorkDone(CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = QueueWorkDoneCallback<>,
-              typename CbChar = std::function<void(QueueWorkDoneStatus status, const char* message)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future OnSubmittedWorkDone(CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future OnSubmittedWorkDone(CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future OnSubmittedWorkDone(CallbackMode callbackMode, F callback) const;
     inline void SetLabel(StringView label) const;
     inline void Submit(size_t commandCount, CommandBuffer const * commands) const;
     inline void WriteBuffer(Buffer const& buffer, uint64_t bufferOffset, void const * data, size_t size) const;
@@ -1956,6 +1944,7 @@ class ResourceTable : public ObjectBase<ResourceTable, WGPUResourceTable> {
     inline uint32_t GetSize() const;
     inline uint32_t InsertBinding(BindingResource const * resource) const;
     inline ConvertibleStatus RemoveBinding(uint32_t slot) const;
+    inline void SetLabel(StringView label) const;
     inline ConvertibleStatus Update(uint32_t slot, BindingResource const * resource) const;
 
 
@@ -1984,16 +1973,10 @@ class ShaderModule : public ObjectBase<ShaderModule, WGPUShaderModule> {
     using ObjectBase::ObjectBase;
     using ObjectBase::operator=;
 
-    template <typename F, typename T,
-              typename Cb = CompilationInfoCallback<T>,
-              typename CbChar = void (CompilationInfoRequestStatus status, CompilationInfo const * compilationInfo, T userdata),
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*> || std::is_convertible_v<F, CbChar*>>>
-    Future GetCompilationInfo(CallbackMode callbackMode,F callback, T userdata) const;
-    template <typename L,
-              typename Cb = CompilationInfoCallback<>,
-              typename CbChar = std::function<void(CompilationInfoRequestStatus status, CompilationInfo const * compilationInfo)>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb> || std::is_convertible_v<L, CbChar>>>
-    Future GetCompilationInfo(CallbackMode callbackMode,L callback) const;
+    template <typename F, typename T>
+    Future GetCompilationInfo(CallbackMode callbackMode, F callback, T userdata) const;
+    template <typename F>
+    Future GetCompilationInfo(CallbackMode callbackMode, F callback) const;
     inline void SetLabel(StringView label) const;
 
 
@@ -2235,54 +2218,52 @@ static_assert(offsetof(ChainedStruct, nextInChain) == offsetof(WGPUChainedStruct
 static_assert(offsetof(ChainedStruct, sType) == offsetof(WGPUChainedStruct, sType),
     "offsetof mismatch for ChainedStruct::sType");
 
-
 // Can be chained in AdapterInfo
 struct AdapterPropertiesD3D : ChainedStructOut {
     inline AdapterPropertiesD3D();
-
     struct Init;
     inline AdapterPropertiesD3D(Init&& init);
     inline operator const WGPUAdapterPropertiesD3D&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t shaderModel;
 };
 
 // Can be chained in AdapterInfo
-struct AdapterPropertiesExplicitComputeSubgroupSizeConfigs : ChainedStructOut {
-    inline AdapterPropertiesExplicitComputeSubgroupSizeConfigs();
-
+struct AdapterPropertiesDrm : ChainedStructOut {
+    inline AdapterPropertiesDrm();
     struct Init;
-    inline AdapterPropertiesExplicitComputeSubgroupSizeConfigs(Init&& init);
-    inline operator const WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs&() const noexcept;
+    inline AdapterPropertiesDrm(Init&& init);
+    inline operator const WGPUAdapterPropertiesDrm&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
-    alignas(kFirstMemberAlignment) uint32_t minExplicitComputeSubgroupSize;
-    uint32_t maxExplicitComputeSubgroupSize;
-    uint32_t maxComputeWorkgroupSubgroups;
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(Bool));
+    alignas(kFirstMemberAlignment) Bool hasPrimary = false;
+    Bool hasRender = false;
+    uint64_t primaryMajor = 0;
+    uint64_t primaryMinor = 0;
+    uint64_t renderMajor = 0;
+    uint64_t renderMinor = 0;
 };
 
 // Can be chained in AdapterInfo
 struct AdapterPropertiesVk : ChainedStructOut {
     inline AdapterPropertiesVk();
-
     struct Init;
     inline AdapterPropertiesVk(Init&& init);
     inline operator const WGPUAdapterPropertiesVk&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t driverVersion;
 };
 
 // Can be chained in AdapterInfo
 struct AdapterPropertiesWGPU : ChainedStructOut {
     inline AdapterPropertiesWGPU();
-
     struct Init;
     inline AdapterPropertiesWGPU(Init&& init);
     inline operator const WGPUAdapterPropertiesWGPU&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(BackendType));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(BackendType));
     alignas(kFirstMemberAlignment) BackendType backendType = BackendType::Undefined;
 };
 
@@ -2317,7 +2298,6 @@ struct BufferBindingLayout {
 // Can be chained in BufferDescriptor
 struct BufferHostMappedPointer : ChainedStruct {
     inline BufferHostMappedPointer();
-
     struct Init;
     inline BufferHostMappedPointer(Init&& init);
     inline operator const WGPUBufferHostMappedPointer&() const noexcept;
@@ -2337,10 +2317,19 @@ struct Color {
     double a;
 };
 
+struct ColorSpaceDawn {
+    inline operator const WGPUColorSpaceDawn&() const noexcept;
+
+    ChainedStruct const * nextInChain = nullptr;
+    ColorSpacePrimariesDawn primaries = {};
+    ColorSpaceTransferDawn transfer = ColorSpaceTransferDawn::Identity;
+    ColorSpaceYCbCrRangeDawn yCbCrRange = ColorSpaceYCbCrRangeDawn::Identity;
+    ColorSpaceYCbCrMatrixDawn yCbCrMatrix = ColorSpaceYCbCrMatrixDawn::Identity;
+};
+
 // Can be chained in ColorTargetState
 struct ColorTargetStateExpandResolveTextureDawn : ChainedStruct {
     inline ColorTargetStateExpandResolveTextureDawn();
-
     struct Init;
     inline ColorTargetStateExpandResolveTextureDawn(Init&& init);
     inline operator const WGPUColorTargetStateExpandResolveTextureDawn&() const noexcept;
@@ -2359,12 +2348,11 @@ struct CommandBufferDescriptor {
 // Can be chained in Limits
 struct CompatibilityModeLimits : ChainedStructOut {
     inline CompatibilityModeLimits();
-
     struct Init;
     inline CompatibilityModeLimits(Init&& init);
     inline operator const WGPUCompatibilityModeLimits&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t maxStorageBuffersInVertexStage = kLimitU32Undefined;
     uint32_t maxStorageTexturesInVertexStage = kLimitU32Undefined;
     uint32_t maxStorageBuffersInFragmentStage = kLimitU32Undefined;
@@ -2396,19 +2384,17 @@ struct CopyTextureForBrowserOptions {
 // Can be chained in AdapterInfo
 struct DawnAdapterPropertiesPowerPreference : ChainedStructOut {
     inline DawnAdapterPropertiesPowerPreference();
-
     struct Init;
     inline DawnAdapterPropertiesPowerPreference(Init&& init);
     inline operator const WGPUDawnAdapterPropertiesPowerPreference&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(PowerPreference));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(PowerPreference));
     alignas(kFirstMemberAlignment) PowerPreference powerPreference = PowerPreference::Undefined;
 };
 
 // Can be chained in BufferDescriptor
 struct DawnBufferDescriptorErrorInfoFromWireClient : ChainedStruct {
     inline DawnBufferDescriptorErrorInfoFromWireClient();
-
     struct Init;
     inline DawnBufferDescriptorErrorInfoFromWireClient(Init&& init);
     inline operator const WGPUDawnBufferDescriptorErrorInfoFromWireClient&() const noexcept;
@@ -2420,7 +2406,6 @@ struct DawnBufferDescriptorErrorInfoFromWireClient : ChainedStruct {
 // Can be chained in DeviceDescriptor
 struct DawnCacheDeviceDescriptor : ChainedStruct {
     inline DawnCacheDeviceDescriptor();
-
     struct Init;
     inline DawnCacheDeviceDescriptor(Init&& init);
     inline operator const WGPUDawnCacheDeviceDescriptor&() const noexcept;
@@ -2435,7 +2420,6 @@ struct DawnCacheDeviceDescriptor : ChainedStruct {
 // Can be chained in CompilationMessage
 struct DawnCompilationMessageUtf16 : ChainedStruct {
     inline DawnCompilationMessageUtf16();
-
     struct Init;
     inline DawnCompilationMessageUtf16(Init&& init);
     inline operator const WGPUDawnCompilationMessageUtf16&() const noexcept;
@@ -2449,7 +2433,6 @@ struct DawnCompilationMessageUtf16 : ChainedStruct {
 // Can be chained in DeviceDescriptor
 struct DawnConsumeAdapterDescriptor : ChainedStruct {
     inline DawnConsumeAdapterDescriptor();
-
     struct Init;
     inline DawnConsumeAdapterDescriptor(Init&& init);
     inline operator const WGPUDawnConsumeAdapterDescriptor&() const noexcept;
@@ -2461,7 +2444,6 @@ struct DawnConsumeAdapterDescriptor : ChainedStruct {
 // Can be chained in DeviceDescriptor
 struct DawnDeviceAllocatorControl : ChainedStruct {
     inline DawnDeviceAllocatorControl();
-
     struct Init;
     inline DawnDeviceAllocatorControl(Init&& init);
     inline operator const WGPUDawnDeviceAllocatorControl&() const noexcept;
@@ -2480,7 +2462,6 @@ struct DawnDrmFormatProperties {
 // Can be chained in CommandEncoderDescriptor
 struct DawnEncoderInternalUsageDescriptor : ChainedStruct {
     inline DawnEncoderInternalUsageDescriptor();
-
     struct Init;
     inline DawnEncoderInternalUsageDescriptor(Init&& init);
     inline operator const WGPUDawnEncoderInternalUsageDescriptor&() const noexcept;
@@ -2492,7 +2473,6 @@ struct DawnEncoderInternalUsageDescriptor : ChainedStruct {
 // Can be chained in BufferDescriptor
 struct DawnFakeBufferOOMForTesting : ChainedStruct {
     inline DawnFakeBufferOOMForTesting();
-
     struct Init;
     inline DawnFakeBufferOOMForTesting(Init&& init);
     inline operator const WGPUDawnFakeBufferOOMForTesting&() const noexcept;
@@ -2506,28 +2486,25 @@ struct DawnFakeBufferOOMForTesting : ChainedStruct {
 // Can be chained in DeviceDescriptor
 struct DawnFakeDeviceInitializeErrorForTesting : ChainedStruct {
     inline DawnFakeDeviceInitializeErrorForTesting();
-
     struct Init;
     inline DawnFakeDeviceInitializeErrorForTesting(Init&& init);
     inline operator const WGPUDawnFakeDeviceInitializeErrorForTesting&() const noexcept;
 
-};
+    };
 
 // Can be chained in Limits
 struct DawnHostMappedPointerLimits : ChainedStructOut {
     inline DawnHostMappedPointerLimits();
-
     struct Init;
     inline DawnHostMappedPointerLimits(Init&& init);
     inline operator const WGPUDawnHostMappedPointerLimits&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t hostMappedPointerAlignment = kLimitU32Undefined;
 };
 
 struct DawnInjectedInvalidSType : ChainedStruct {
     inline DawnInjectedInvalidSType();
-
     struct Init;
     inline DawnInjectedInvalidSType(Init&& init);
     inline operator const WGPUDawnInjectedInvalidSType&() const noexcept;
@@ -2539,7 +2516,6 @@ struct DawnInjectedInvalidSType : ChainedStruct {
 // Can be chained in RenderPassDescriptor
 struct DawnRenderPassSampleCount : ChainedStruct {
     inline DawnRenderPassSampleCount();
-
     struct Init;
     inline DawnRenderPassSampleCount(Init&& init);
     inline operator const WGPUDawnRenderPassSampleCount&() const noexcept;
@@ -2551,7 +2527,6 @@ struct DawnRenderPassSampleCount : ChainedStruct {
 // Can be chained in ShaderModuleDescriptor
 struct DawnShaderModuleSPIRVOptionsDescriptor : ChainedStruct {
     inline DawnShaderModuleSPIRVOptionsDescriptor();
-
     struct Init;
     inline DawnShaderModuleSPIRVOptionsDescriptor(Init&& init);
     inline operator const WGPUDawnShaderModuleSPIRVOptionsDescriptor&() const noexcept;
@@ -2563,19 +2538,17 @@ struct DawnShaderModuleSPIRVOptionsDescriptor : ChainedStruct {
 // Can be chained in Limits
 struct DawnTexelCopyBufferRowAlignmentLimits : ChainedStructOut {
     inline DawnTexelCopyBufferRowAlignmentLimits();
-
     struct Init;
     inline DawnTexelCopyBufferRowAlignmentLimits(Init&& init);
     inline operator const WGPUDawnTexelCopyBufferRowAlignmentLimits&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t minTexelCopyBufferRowAlignment = kLimitU32Undefined;
 };
 
 // Can be chained in TextureDescriptor
 struct DawnTextureInternalUsageDescriptor : ChainedStruct {
     inline DawnTextureInternalUsageDescriptor();
-
     struct Init;
     inline DawnTextureInternalUsageDescriptor(Init&& init);
     inline operator const WGPUDawnTextureInternalUsageDescriptor&() const noexcept;
@@ -2589,7 +2562,6 @@ struct DawnTextureInternalUsageDescriptor : ChainedStruct {
 // Can be chained in DeviceDescriptor
 struct DawnTogglesDescriptor : ChainedStruct {
     inline DawnTogglesDescriptor();
-
     struct Init;
     inline DawnTogglesDescriptor(Init&& init);
     inline operator const WGPUDawnTogglesDescriptor&() const noexcept;
@@ -2604,7 +2576,6 @@ struct DawnTogglesDescriptor : ChainedStruct {
 // Can be chained in InstanceDescriptor
 struct DawnWGSLBlocklist : ChainedStruct {
     inline DawnWGSLBlocklist();
-
     struct Init;
     inline DawnWGSLBlocklist(Init&& init);
     inline operator const WGPUDawnWGSLBlocklist&() const noexcept;
@@ -2617,7 +2588,6 @@ struct DawnWGSLBlocklist : ChainedStruct {
 // Can be chained in InstanceDescriptor
 struct DawnWireWGSLControl : ChainedStruct {
     inline DawnWireWGSLControl();
-
     struct Init;
     inline DawnWireWGSLControl(Init&& init);
     inline operator const WGPUDawnWireWGSLControl&() const noexcept;
@@ -2631,7 +2601,6 @@ struct DawnWireWGSLControl : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct EmscriptenSurfaceSourceCanvasHTMLSelector : ChainedStruct {
     inline EmscriptenSurfaceSourceCanvasHTMLSelector();
-
     struct Init;
     inline EmscriptenSurfaceSourceCanvasHTMLSelector(Init&& init);
     inline operator const WGPUEmscriptenSurfaceSourceCanvasHTMLSelector&() const noexcept;
@@ -2658,7 +2627,6 @@ struct Extent3D {
 // Can be chained in BindGroupEntry
 struct ExternalTextureBindingEntry : ChainedStruct {
     inline ExternalTextureBindingEntry();
-
     struct Init;
     inline ExternalTextureBindingEntry(Init&& init);
     inline operator const WGPUExternalTextureBindingEntry&() const noexcept;
@@ -2670,12 +2638,11 @@ struct ExternalTextureBindingEntry : ChainedStruct {
 // Can be chained in BindGroupLayoutEntry
 struct ExternalTextureBindingLayout : ChainedStruct {
     inline ExternalTextureBindingLayout();
-
     struct Init;
     inline ExternalTextureBindingLayout(Init&& init);
     inline operator const WGPUExternalTextureBindingLayout&() const noexcept;
 
-};
+    };
 
 struct Future {
     inline operator const WGPUFuture&() const noexcept;
@@ -2739,7 +2706,6 @@ struct PassTimestampWrites {
 // Can be chained in PipelineLayoutDescriptor
 struct PipelineLayoutResourceTable : ChainedStruct {
     inline PipelineLayoutResourceTable();
-
     struct Init;
     inline PipelineLayoutResourceTable(Init&& init);
     inline operator const WGPUPipelineLayoutResourceTable&() const noexcept;
@@ -2821,7 +2787,6 @@ struct RenderPassDepthStencilAttachment {
 // Can be chained in RenderPassDescriptor
 struct RenderPassDescriptorResolveRect : ChainedStruct {
     inline RenderPassDescriptorResolveRect();
-
     struct Init;
     inline RenderPassDescriptorResolveRect(Init&& init);
     inline operator const WGPURenderPassDescriptorResolveRect&() const noexcept;
@@ -2838,7 +2803,6 @@ struct RenderPassDescriptorResolveRect : ChainedStruct {
 // Can be chained in RenderPassDescriptor
 struct RenderPassMaxDrawCount : ChainedStruct {
     inline RenderPassMaxDrawCount();
-
     struct Init;
     inline RenderPassMaxDrawCount(Init&& init);
     inline operator const WGPURenderPassMaxDrawCount&() const noexcept;
@@ -2850,17 +2814,15 @@ struct RenderPassMaxDrawCount : ChainedStruct {
 // Can be chained in RequestAdapterOptions
 struct RequestAdapterWebGPUBackendOptions : ChainedStruct {
     inline RequestAdapterWebGPUBackendOptions();
-
     struct Init;
     inline RequestAdapterWebGPUBackendOptions(Init&& init);
     inline operator const WGPURequestAdapterWebGPUBackendOptions&() const noexcept;
 
-};
+    };
 
 // Can be chained in RequestAdapterOptions
 struct RequestAdapterWebXROptions : ChainedStruct {
     inline RequestAdapterWebXROptions();
-
     struct Init;
     inline RequestAdapterWebXROptions(Init&& init);
     inline operator const WGPURequestAdapterWebXROptions&() const noexcept;
@@ -2887,7 +2849,6 @@ struct SamplerBindingLayout {
 // Can be chained in ShaderModuleDescriptor
 struct ShaderModuleCompilationOptions : ChainedStruct {
     inline ShaderModuleCompilationOptions();
-
     struct Init;
     inline ShaderModuleCompilationOptions(Init&& init);
     inline operator const WGPUShaderModuleCompilationOptions&() const noexcept;
@@ -2899,7 +2860,6 @@ struct ShaderModuleCompilationOptions : ChainedStruct {
 // Can be chained in ShaderModuleDescriptor
 struct ShaderSourceSPIRV : ChainedStruct {
     inline ShaderSourceSPIRV();
-
     struct Init;
     inline ShaderSourceSPIRV(Init&& init);
     inline operator const WGPUShaderSourceSPIRV&() const noexcept;
@@ -2912,7 +2872,6 @@ struct ShaderSourceSPIRV : ChainedStruct {
 // Can be chained in ShaderModuleDescriptor
 struct ShaderSourceWGSL : ChainedStruct {
     inline ShaderSourceWGSL();
-
     struct Init;
     inline ShaderSourceWGSL(Init&& init);
     inline operator const WGPUShaderSourceWGSL&() const noexcept;
@@ -2934,7 +2893,6 @@ struct SharedBufferMemoryBeginAccessDescriptor {
 // Can be chained in SharedBufferMemoryDescriptor
 struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor : ChainedStruct {
     inline SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor();
-
     struct Init;
     inline SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor(Init&& init);
     inline operator const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor&() const noexcept;
@@ -2975,7 +2933,6 @@ struct SharedBufferMemoryProperties {
 // Can be chained in SharedFenceDescriptor
 struct SharedFenceDXGISharedHandleDescriptor : ChainedStruct {
     inline SharedFenceDXGISharedHandleDescriptor();
-
     struct Init;
     inline SharedFenceDXGISharedHandleDescriptor(Init&& init);
     inline operator const WGPUSharedFenceDXGISharedHandleDescriptor&() const noexcept;
@@ -2987,19 +2944,17 @@ struct SharedFenceDXGISharedHandleDescriptor : ChainedStruct {
 // Can be chained in SharedFenceExportInfo
 struct SharedFenceDXGISharedHandleExportInfo : ChainedStructOut {
     inline SharedFenceDXGISharedHandleExportInfo();
-
     struct Init;
     inline SharedFenceDXGISharedHandleExportInfo(Init&& init);
     inline operator const WGPUSharedFenceDXGISharedHandleExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(void *));
     alignas(kFirstMemberAlignment) void * handle;
 };
 
 // Can be chained in SharedFenceDescriptor
 struct SharedFenceEGLSyncDescriptor : ChainedStruct {
     inline SharedFenceEGLSyncDescriptor();
-
     struct Init;
     inline SharedFenceEGLSyncDescriptor(Init&& init);
     inline operator const WGPUSharedFenceEGLSyncDescriptor&() const noexcept;
@@ -3011,19 +2966,17 @@ struct SharedFenceEGLSyncDescriptor : ChainedStruct {
 // Can be chained in SharedFenceExportInfo
 struct SharedFenceEGLSyncExportInfo : ChainedStructOut {
     inline SharedFenceEGLSyncExportInfo();
-
     struct Init;
     inline SharedFenceEGLSyncExportInfo(Init&& init);
     inline operator const WGPUSharedFenceEGLSyncExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(void *));
     alignas(kFirstMemberAlignment) void * sync;
 };
 
 // Can be chained in SharedFenceDescriptor
 struct SharedFenceMTLSharedEventDescriptor : ChainedStruct {
     inline SharedFenceMTLSharedEventDescriptor();
-
     struct Init;
     inline SharedFenceMTLSharedEventDescriptor(Init&& init);
     inline operator const WGPUSharedFenceMTLSharedEventDescriptor&() const noexcept;
@@ -3035,19 +2988,17 @@ struct SharedFenceMTLSharedEventDescriptor : ChainedStruct {
 // Can be chained in SharedFenceExportInfo
 struct SharedFenceMTLSharedEventExportInfo : ChainedStructOut {
     inline SharedFenceMTLSharedEventExportInfo();
-
     struct Init;
     inline SharedFenceMTLSharedEventExportInfo(Init&& init);
     inline operator const WGPUSharedFenceMTLSharedEventExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(void *));
     alignas(kFirstMemberAlignment) void * sharedEvent;
 };
 
 // Can be chained in SharedFenceDescriptor
 struct SharedFenceSyncFDDescriptor : ChainedStruct {
     inline SharedFenceSyncFDDescriptor();
-
     struct Init;
     inline SharedFenceSyncFDDescriptor(Init&& init);
     inline operator const WGPUSharedFenceSyncFDDescriptor&() const noexcept;
@@ -3059,19 +3010,17 @@ struct SharedFenceSyncFDDescriptor : ChainedStruct {
 // Can be chained in SharedFenceExportInfo
 struct SharedFenceSyncFDExportInfo : ChainedStructOut {
     inline SharedFenceSyncFDExportInfo();
-
     struct Init;
     inline SharedFenceSyncFDExportInfo(Init&& init);
     inline operator const WGPUSharedFenceSyncFDExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(int));
     alignas(kFirstMemberAlignment) int handle;
 };
 
 // Can be chained in SharedFenceDescriptor
 struct SharedFenceVkSemaphoreOpaqueFDDescriptor : ChainedStruct {
     inline SharedFenceVkSemaphoreOpaqueFDDescriptor();
-
     struct Init;
     inline SharedFenceVkSemaphoreOpaqueFDDescriptor(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor&() const noexcept;
@@ -3083,19 +3032,17 @@ struct SharedFenceVkSemaphoreOpaqueFDDescriptor : ChainedStruct {
 // Can be chained in SharedFenceExportInfo
 struct SharedFenceVkSemaphoreOpaqueFDExportInfo : ChainedStructOut {
     inline SharedFenceVkSemaphoreOpaqueFDExportInfo();
-
     struct Init;
     inline SharedFenceVkSemaphoreOpaqueFDExportInfo(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(int));
     alignas(kFirstMemberAlignment) int handle;
 };
 
 // Can be chained in SharedFenceDescriptor
 struct SharedFenceVkSemaphoreZirconHandleDescriptor : ChainedStruct {
     inline SharedFenceVkSemaphoreZirconHandleDescriptor();
-
     struct Init;
     inline SharedFenceVkSemaphoreZirconHandleDescriptor(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreZirconHandleDescriptor&() const noexcept;
@@ -3107,19 +3054,17 @@ struct SharedFenceVkSemaphoreZirconHandleDescriptor : ChainedStruct {
 // Can be chained in SharedFenceExportInfo
 struct SharedFenceVkSemaphoreZirconHandleExportInfo : ChainedStructOut {
     inline SharedFenceVkSemaphoreZirconHandleExportInfo();
-
     struct Init;
     inline SharedFenceVkSemaphoreZirconHandleExportInfo(Init&& init);
     inline operator const WGPUSharedFenceVkSemaphoreZirconHandleExportInfo&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
     alignas(kFirstMemberAlignment) uint32_t handle;
 };
 
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct {
     inline SharedTextureMemoryAHardwareBufferDescriptor();
-
     struct Init;
     inline SharedTextureMemoryAHardwareBufferDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryAHardwareBufferDescriptor&() const noexcept;
@@ -3131,7 +3076,6 @@ struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryBeginAccessDescriptor
 struct SharedTextureMemoryD3D11BeginState : ChainedStruct {
     inline SharedTextureMemoryD3D11BeginState();
-
     struct Init;
     inline SharedTextureMemoryD3D11BeginState(Init&& init);
     inline operator const WGPUSharedTextureMemoryD3D11BeginState&() const noexcept;
@@ -3143,7 +3087,6 @@ struct SharedTextureMemoryD3D11BeginState : ChainedStruct {
 // Can be chained in SharedTextureMemoryBeginAccessDescriptor
 struct SharedTextureMemoryD3DSwapchainBeginState : ChainedStruct {
     inline SharedTextureMemoryD3DSwapchainBeginState();
-
     struct Init;
     inline SharedTextureMemoryD3DSwapchainBeginState(Init&& init);
     inline operator const WGPUSharedTextureMemoryD3DSwapchainBeginState&() const noexcept;
@@ -3163,7 +3106,6 @@ struct SharedTextureMemoryDmaBufPlane {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryDXGISharedHandleDescriptor : ChainedStruct {
     inline SharedTextureMemoryDXGISharedHandleDescriptor();
-
     struct Init;
     inline SharedTextureMemoryDXGISharedHandleDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryDXGISharedHandleDescriptor&() const noexcept;
@@ -3176,7 +3118,6 @@ struct SharedTextureMemoryDXGISharedHandleDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryEGLImageDescriptor : ChainedStruct {
     inline SharedTextureMemoryEGLImageDescriptor();
-
     struct Init;
     inline SharedTextureMemoryEGLImageDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryEGLImageDescriptor&() const noexcept;
@@ -3188,7 +3129,6 @@ struct SharedTextureMemoryEGLImageDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryIOSurfaceDescriptor : ChainedStruct {
     inline SharedTextureMemoryIOSurfaceDescriptor();
-
     struct Init;
     inline SharedTextureMemoryIOSurfaceDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryIOSurfaceDescriptor&() const noexcept;
@@ -3201,7 +3141,6 @@ struct SharedTextureMemoryIOSurfaceDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryOpaqueFDDescriptor : ChainedStruct {
     inline SharedTextureMemoryOpaqueFDDescriptor();
-
     struct Init;
     inline SharedTextureMemoryOpaqueFDDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryOpaqueFDDescriptor&() const noexcept;
@@ -3217,7 +3156,6 @@ struct SharedTextureMemoryOpaqueFDDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryVkDedicatedAllocationDescriptor : ChainedStruct {
     inline SharedTextureMemoryVkDedicatedAllocationDescriptor();
-
     struct Init;
     inline SharedTextureMemoryVkDedicatedAllocationDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor&() const noexcept;
@@ -3229,7 +3167,6 @@ struct SharedTextureMemoryVkDedicatedAllocationDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryBeginAccessDescriptor
 struct SharedTextureMemoryVkImageLayoutBeginState : ChainedStruct {
     inline SharedTextureMemoryVkImageLayoutBeginState();
-
     struct Init;
     inline SharedTextureMemoryVkImageLayoutBeginState(Init&& init);
     inline operator const WGPUSharedTextureMemoryVkImageLayoutBeginState&() const noexcept;
@@ -3242,12 +3179,11 @@ struct SharedTextureMemoryVkImageLayoutBeginState : ChainedStruct {
 // Can be chained in SharedTextureMemoryEndAccessState
 struct SharedTextureMemoryVkImageLayoutEndState : ChainedStructOut {
     inline SharedTextureMemoryVkImageLayoutEndState();
-
     struct Init;
     inline SharedTextureMemoryVkImageLayoutEndState(Init&& init);
     inline operator const WGPUSharedTextureMemoryVkImageLayoutEndState&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int32_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(int32_t));
     alignas(kFirstMemberAlignment) int32_t oldLayout;
     int32_t newLayout;
 };
@@ -3255,7 +3191,6 @@ struct SharedTextureMemoryVkImageLayoutEndState : ChainedStructOut {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryZirconHandleDescriptor : ChainedStruct {
     inline SharedTextureMemoryZirconHandleDescriptor();
-
     struct Init;
     inline SharedTextureMemoryZirconHandleDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryZirconHandleDescriptor&() const noexcept;
@@ -3268,7 +3203,6 @@ struct SharedTextureMemoryZirconHandleDescriptor : ChainedStruct {
 // Can be chained in BindGroupLayoutEntry
 struct StaticSamplerBindingLayout : ChainedStruct {
     inline StaticSamplerBindingLayout();
-
     struct Init;
     inline StaticSamplerBindingLayout(Init&& init);
     inline operator const WGPUStaticSamplerBindingLayout&() const noexcept;
@@ -3383,7 +3317,6 @@ struct SurfaceCapabilities {
 // Can be chained in SurfaceDescriptor
 struct SurfaceColorManagement : ChainedStruct {
     inline SurfaceColorManagement();
-
     struct Init;
     inline SurfaceColorManagement(Init&& init);
     inline operator const WGPUSurfaceColorManagement&() const noexcept;
@@ -3411,7 +3344,6 @@ struct SurfaceConfiguration {
 // Can be chained in SurfaceDescriptor
 struct SurfaceDescriptorFromWindowsCoreWindow : ChainedStruct {
     inline SurfaceDescriptorFromWindowsCoreWindow();
-
     struct Init;
     inline SurfaceDescriptorFromWindowsCoreWindow(Init&& init);
     inline operator const WGPUSurfaceDescriptorFromWindowsCoreWindow&() const noexcept;
@@ -3423,7 +3355,6 @@ struct SurfaceDescriptorFromWindowsCoreWindow : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceDescriptorFromWindowsUWPSwapChainPanel : ChainedStruct {
     inline SurfaceDescriptorFromWindowsUWPSwapChainPanel();
-
     struct Init;
     inline SurfaceDescriptorFromWindowsUWPSwapChainPanel(Init&& init);
     inline operator const WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel&() const noexcept;
@@ -3435,7 +3366,6 @@ struct SurfaceDescriptorFromWindowsUWPSwapChainPanel : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceDescriptorFromWindowsWinUISwapChainPanel : ChainedStruct {
     inline SurfaceDescriptorFromWindowsWinUISwapChainPanel();
-
     struct Init;
     inline SurfaceDescriptorFromWindowsWinUISwapChainPanel(Init&& init);
     inline operator const WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel&() const noexcept;
@@ -3447,7 +3377,6 @@ struct SurfaceDescriptorFromWindowsWinUISwapChainPanel : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceSourceAndroidNativeWindow : ChainedStruct {
     inline SurfaceSourceAndroidNativeWindow();
-
     struct Init;
     inline SurfaceSourceAndroidNativeWindow(Init&& init);
     inline operator const WGPUSurfaceSourceAndroidNativeWindow&() const noexcept;
@@ -3459,7 +3388,6 @@ struct SurfaceSourceAndroidNativeWindow : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceSourceMetalLayer : ChainedStruct {
     inline SurfaceSourceMetalLayer();
-
     struct Init;
     inline SurfaceSourceMetalLayer(Init&& init);
     inline operator const WGPUSurfaceSourceMetalLayer&() const noexcept;
@@ -3471,7 +3399,6 @@ struct SurfaceSourceMetalLayer : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceSourceWaylandSurface : ChainedStruct {
     inline SurfaceSourceWaylandSurface();
-
     struct Init;
     inline SurfaceSourceWaylandSurface(Init&& init);
     inline operator const WGPUSurfaceSourceWaylandSurface&() const noexcept;
@@ -3484,7 +3411,6 @@ struct SurfaceSourceWaylandSurface : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceSourceWindowsHWND : ChainedStruct {
     inline SurfaceSourceWindowsHWND();
-
     struct Init;
     inline SurfaceSourceWindowsHWND(Init&& init);
     inline operator const WGPUSurfaceSourceWindowsHWND&() const noexcept;
@@ -3497,7 +3423,6 @@ struct SurfaceSourceWindowsHWND : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceSourceXCBWindow : ChainedStruct {
     inline SurfaceSourceXCBWindow();
-
     struct Init;
     inline SurfaceSourceXCBWindow(Init&& init);
     inline operator const WGPUSurfaceSourceXCBWindow&() const noexcept;
@@ -3510,7 +3435,6 @@ struct SurfaceSourceXCBWindow : ChainedStruct {
 // Can be chained in SurfaceDescriptor
 struct SurfaceSourceXlibWindow : ChainedStruct {
     inline SurfaceSourceXlibWindow();
-
     struct Init;
     inline SurfaceSourceXlibWindow(Init&& init);
     inline operator const WGPUSurfaceSourceXlibWindow&() const noexcept;
@@ -3531,7 +3455,6 @@ struct SurfaceTexture {
 // Can be chained in BindGroupEntry
 struct TexelBufferBindingEntry : ChainedStruct {
     inline TexelBufferBindingEntry();
-
     struct Init;
     inline TexelBufferBindingEntry(Init&& init);
     inline operator const WGPUTexelBufferBindingEntry&() const noexcept;
@@ -3543,7 +3466,6 @@ struct TexelBufferBindingEntry : ChainedStruct {
 // Can be chained in BindGroupLayoutEntry
 struct TexelBufferBindingLayout : ChainedStruct {
     inline TexelBufferBindingLayout();
-
     struct Init;
     inline TexelBufferBindingLayout(Init&& init);
     inline operator const WGPUTexelBufferBindingLayout&() const noexcept;
@@ -3583,7 +3505,6 @@ struct TextureBindingLayout {
 // Can be chained in TextureDescriptor
 struct TextureBindingViewDimension : ChainedStruct {
     inline TextureBindingViewDimension();
-
     struct Init;
     inline TextureBindingViewDimension(Init&& init);
     inline operator const WGPUTextureBindingViewDimension&() const noexcept;
@@ -3614,7 +3535,6 @@ struct VertexAttribute {
 // Can be chained in TextureViewDescriptor
 struct YCbCrVkDescriptor : ChainedStruct {
     inline YCbCrVkDescriptor();
-
     struct Init;
     inline YCbCrVkDescriptor(Init&& init);
     inline operator const WGPUYCbCrVkDescriptor&() const noexcept;
@@ -3637,7 +3557,6 @@ struct YCbCrVkDescriptor : ChainedStruct {
 // Can be chained in AdapterInfo
 struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
     inline AdapterPropertiesMemoryHeaps();
-
     struct Init;
     inline AdapterPropertiesMemoryHeaps(Init&& init);
     inline ~AdapterPropertiesMemoryHeaps();
@@ -3647,7 +3566,7 @@ struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
     inline AdapterPropertiesMemoryHeaps& operator=(AdapterPropertiesMemoryHeaps&&);
     inline operator const WGPUAdapterPropertiesMemoryHeaps&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t const heapCount = {};
     MemoryHeapInfo const * const heapInfo = nullptr;
 
@@ -3659,7 +3578,6 @@ struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
 // Can be chained in AdapterInfo
 struct AdapterPropertiesSubgroupMatrixConfigs : ChainedStructOut {
     inline AdapterPropertiesSubgroupMatrixConfigs();
-
     struct Init;
     inline AdapterPropertiesSubgroupMatrixConfigs(Init&& init);
     inline ~AdapterPropertiesSubgroupMatrixConfigs();
@@ -3669,7 +3587,7 @@ struct AdapterPropertiesSubgroupMatrixConfigs : ChainedStructOut {
     inline AdapterPropertiesSubgroupMatrixConfigs& operator=(AdapterPropertiesSubgroupMatrixConfigs&&);
     inline operator const WGPUAdapterPropertiesSubgroupMatrixConfigs&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t const configCount = {};
     SubgroupMatrixConfig const * const configs = nullptr;
 
@@ -3766,7 +3684,6 @@ struct ComputeState {
 // Can be chained in DawnFormatCapabilities
 struct DawnDrmFormatCapabilities : ChainedStructOut {
     inline DawnDrmFormatCapabilities();
-
     struct Init;
     inline DawnDrmFormatCapabilities(Init&& init);
     inline ~DawnDrmFormatCapabilities();
@@ -3776,7 +3693,7 @@ struct DawnDrmFormatCapabilities : ChainedStructOut {
     inline DawnDrmFormatCapabilities& operator=(DawnDrmFormatCapabilities&&);
     inline operator const WGPUDawnDrmFormatCapabilities&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(size_t));
     alignas(kFirstMemberAlignment) size_t const propertiesCount = {};
     DawnDrmFormatProperties const * const properties = nullptr;
 
@@ -3886,7 +3803,6 @@ struct Limits {
 // Can be chained in PipelineLayoutDescriptor
 struct PipelineLayoutPixelLocalStorage : ChainedStruct {
     inline PipelineLayoutPixelLocalStorage();
-
     struct Init;
     inline PipelineLayoutPixelLocalStorage(Init&& init);
     inline operator const WGPUPipelineLayoutPixelLocalStorage&() const noexcept;
@@ -3912,7 +3828,6 @@ struct RenderPassColorAttachment {
 // Can be chained in RenderPassDescriptor
 struct RenderPassRenderAreaRect : ChainedStruct {
     inline RenderPassRenderAreaRect();
-
     struct Init;
     inline RenderPassRenderAreaRect(Init&& init);
     inline operator const WGPURenderPassRenderAreaRect&() const noexcept;
@@ -3992,12 +3907,11 @@ struct SharedFenceExportInfo {
 // Can be chained in SharedTextureMemoryProperties
 struct SharedTextureMemoryAHardwareBufferProperties : ChainedStructOut {
     inline SharedTextureMemoryAHardwareBufferProperties();
-
     struct Init;
     inline SharedTextureMemoryAHardwareBufferProperties(Init&& init);
     inline operator const WGPUSharedTextureMemoryAHardwareBufferProperties&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(YCbCrVkDescriptor));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(YCbCrVkDescriptor));
     alignas(kFirstMemberAlignment) YCbCrVkDescriptor yCbCrInfo = {};
 };
 
@@ -4015,7 +3929,6 @@ struct SharedTextureMemoryBeginAccessDescriptor {
 // Can be chained in SharedTextureMemoryDescriptor
 struct SharedTextureMemoryDmaBufDescriptor : ChainedStruct {
     inline SharedTextureMemoryDmaBufDescriptor();
-
     struct Init;
     inline SharedTextureMemoryDmaBufDescriptor(Init&& init);
     inline operator const WGPUSharedTextureMemoryDmaBufDescriptor&() const noexcept;
@@ -4031,12 +3944,11 @@ struct SharedTextureMemoryDmaBufDescriptor : ChainedStruct {
 // Can be chained in SharedTextureMemoryEndAccessState
 struct SharedTextureMemoryMetalEndAccessState : ChainedStructOut {
     inline SharedTextureMemoryMetalEndAccessState();
-
     struct Init;
     inline SharedTextureMemoryMetalEndAccessState(Init&& init);
     inline operator const WGPUSharedTextureMemoryMetalEndAccessState&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Future));
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(Future));
     alignas(kFirstMemberAlignment) Future commandsScheduledFuture = {};
 };
 
@@ -4066,7 +3978,6 @@ struct TexelCopyTextureInfo {
 // Can be chained in TextureViewDescriptor
 struct TextureComponentSwizzleDescriptor : ChainedStruct {
     inline TextureComponentSwizzleDescriptor();
-
     struct Init;
     inline TextureComponentSwizzleDescriptor(Init&& init);
     inline operator const WGPUTextureComponentSwizzleDescriptor&() const noexcept;
@@ -4177,6 +4088,41 @@ struct DawnFormatCapabilities {
     ChainedStructOut  * nextInChain = nullptr;
 };
 
+namespace detail {
+struct DeviceDescriptor {
+    ChainedStruct const * nextInChain = nullptr;
+    StringView label = {};
+    size_t requiredFeatureCount = 0;
+    FeatureName const * requiredFeatures = nullptr;
+    Limits const * requiredLimits = nullptr;
+    QueueDescriptor defaultQueue = {};
+    WGPUDeviceLostCallbackInfo deviceLostCallbackInfo = WGPU_DEVICE_LOST_CALLBACK_INFO_INIT;
+    WGPUUncapturedErrorCallbackInfo uncapturedErrorCallbackInfo = WGPU_UNCAPTURED_ERROR_CALLBACK_INFO_INIT;
+};
+}  // namespace detail
+struct DeviceDescriptor : protected detail::DeviceDescriptor {
+    inline DeviceDescriptor();
+    struct Init;
+    inline DeviceDescriptor(Init&& init);
+    inline operator const WGPUDeviceDescriptor&() const noexcept;
+
+    using detail::DeviceDescriptor::nextInChain;
+    using detail::DeviceDescriptor::label;
+    using detail::DeviceDescriptor::requiredFeatureCount;
+    using detail::DeviceDescriptor::requiredFeatures;
+    using detail::DeviceDescriptor::requiredLimits;
+    using detail::DeviceDescriptor::defaultQueue;
+
+    template <typename F, typename T>
+    void SetDeviceLostCallback(CallbackMode callbackMode, F callback, T userdata);
+    template <typename F>
+    void SetDeviceLostCallback(CallbackMode callbackMode, F callback);
+    template <typename F, typename T>
+    void SetUncapturedErrorCallback(F callback, T userdata);
+    template <typename F>
+    void SetUncapturedErrorCallback(F callback);
+};
+
 struct PipelineLayoutDescriptor {
     inline operator const WGPUPipelineLayoutDescriptor&() const noexcept;
 
@@ -4190,7 +4136,6 @@ struct PipelineLayoutDescriptor {
 // Can be chained in RenderPassDescriptor
 struct RenderPassPixelLocalStorage : ChainedStruct {
     inline RenderPassPixelLocalStorage();
-
     struct Init;
     inline RenderPassPixelLocalStorage(Init&& init);
     inline operator const WGPURenderPassPixelLocalStorage&() const noexcept;
@@ -4302,51 +4247,273 @@ struct RenderPipelineDescriptor {
 };
 
 
+// Callback info handling is generated and/or custom implemented here to convert the types between C and C++.
 namespace detail {
-struct DeviceDescriptor {
-    ChainedStruct const * nextInChain = nullptr;
-    StringView label = {};
-    size_t requiredFeatureCount = 0;
-    FeatureName const * requiredFeatures = nullptr;
-    Limits const * requiredLimits = nullptr;
-    QueueDescriptor defaultQueue = {};
-    WGPUDeviceLostCallbackInfo deviceLostCallbackInfo = WGPU_DEVICE_LOST_CALLBACK_INFO_INIT;
-    WGPUUncapturedErrorCallbackInfo uncapturedErrorCallbackInfo = WGPU_UNCAPTURED_ERROR_CALLBACK_INFO_INIT;
+struct Untyped {};
+
+// The current interface of CppFTraits exposes the following values:
+//   - CppFTraits::capturing: true if the callback is a capturing callback (i.e. a lambda that
+//     captures its environment).
+//   - CppFTraits::PtrT: The C++ callback function pointer type.
+//   - CppFTraits::BaseArgsTuple: A tuple of the C++ arguments minus the user specified typed
+//     parameter.
+//
+// Implementation notes:
+//   - The |Untyped| struct is only used to differentiate whether |T| is a user specified type
+//     in which case we need to strip the type from the callback arguments for speecialization
+//     deduction.
+template <typename CppFT, typename CppFPtr, typename T>
+struct CppFTraitsImpl;
+// Specialization for raw function pointers.
+template <typename CppFT, typename R, typename... CppArgs, typename T>
+struct CppFTraitsImpl<CppFT, R(*)(CppArgs...), T> {
+    using PtrT = R(*)(CppArgs...);
+    static constexpr bool capturing = false;
+
+    static constexpr size_t NumCppArgs = sizeof...(CppArgs);
+    using BaseArgsTuple = decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
+        return std::type_identity<std::tuple<std::tuple_element_t<Is, std::tuple<CppArgs...>>...>>{};
+    }(std::make_index_sequence<std::is_same_v<T, Untyped> ? NumCppArgs : NumCppArgs - 1>{})
+    )::type;
+};
+// Specialization for member function pointers (lambdas);
+template <typename CppFT, typename R, typename C, typename... CppArgs, typename T>
+struct CppFTraitsImpl<CppFT, R(C::*)(CppArgs...) const, T> {
+    using PtrT = R(*)(CppArgs...);
+    static constexpr bool capturing = !std::is_convertible_v<CppFT, PtrT>;
+
+    static constexpr size_t NumCppArgs = sizeof...(CppArgs);
+    using BaseArgsTuple = decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
+        return std::type_identity<std::tuple<std::tuple_element_t<Is, std::tuple<CppArgs...>>...>>{};
+    }(std::make_index_sequence<std::is_same_v<T, Untyped> ? NumCppArgs : NumCppArgs - 1>{})
+    )::type;
+};
+template <typename CppFT, typename T = Untyped>
+struct CppFTraits : CppFTraitsImpl<CppFT, decltype(&CppFT::operator()), T> {};
+template <typename R, typename... CppArgs, typename T>
+struct CppFTraits<R(*)(CppArgs...), T> :
+    CppFTraitsImpl<R(*)(CppArgs...), R(*)(CppArgs...), T> {};
+
+// CArgConverter are specialization structs that specialize a conversion from a C CallbackInfo's
+// callback argument types to a set of valid C++ types. These specializations provide us a way to
+// support additional C++ callback types, i.e. converting raw pointers to more C++ friendly
+// structures when applicable.
+template <typename CInfoT, typename CppArgs>
+struct CArgConverter;
+template <>
+struct CArgConverter<WGPUBufferMapCallbackInfo, std::tuple<MapAsyncStatus, StringView>> {
+    using Result = std::tuple<MapAsyncStatus, StringView>;
+    static Result Convert(WGPUMapAsyncStatus status, WGPUStringView message) {
+        return std::make_tuple(static_cast<MapAsyncStatus>(status), StringView {
+    message.data,
+    message.length
+});
+    }
 };
-}  // namespace detail
-struct DeviceDescriptor : protected detail::DeviceDescriptor {
-    inline operator const WGPUDeviceDescriptor&() const noexcept;
-
-    using detail::DeviceDescriptor::nextInChain;
-    using detail::DeviceDescriptor::label;
-    using detail::DeviceDescriptor::requiredFeatureCount;
-    using detail::DeviceDescriptor::requiredFeatures;
-    using detail::DeviceDescriptor::requiredLimits;
-    using detail::DeviceDescriptor::defaultQueue;
+template <>
+struct CArgConverter<WGPUCompilationInfoCallbackInfo, std::tuple<CompilationInfoRequestStatus, CompilationInfo const *>> {
+    using Result = std::tuple<CompilationInfoRequestStatus, CompilationInfo const *>;
+    static Result Convert(WGPUCompilationInfoRequestStatus status, WGPUCompilationInfo const * compilationInfo) {
+        return std::make_tuple(static_cast<CompilationInfoRequestStatus>(status), reinterpret_cast<CompilationInfo const*>(compilationInfo));
+    }
+};
+template <>
+struct CArgConverter<WGPUCreateComputePipelineAsyncCallbackInfo, std::tuple<CreatePipelineAsyncStatus, ComputePipeline, StringView>> {
+    using Result = std::tuple<CreatePipelineAsyncStatus, ComputePipeline, StringView>;
+    static Result Convert(WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, WGPUStringView message) {
+        return std::make_tuple(static_cast<CreatePipelineAsyncStatus>(status), ComputePipeline::Acquire(pipeline), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPUCreateRenderPipelineAsyncCallbackInfo, std::tuple<CreatePipelineAsyncStatus, RenderPipeline, StringView>> {
+    using Result = std::tuple<CreatePipelineAsyncStatus, RenderPipeline, StringView>;
+    static Result Convert(WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, WGPUStringView message) {
+        return std::make_tuple(static_cast<CreatePipelineAsyncStatus>(status), RenderPipeline::Acquire(pipeline), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPULoggingCallbackInfo, std::tuple<LoggingType, StringView>> {
+    using Result = std::tuple<LoggingType, StringView>;
+    static Result Convert(WGPULoggingType type, WGPUStringView message) {
+        return std::make_tuple(static_cast<LoggingType>(type), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPUPopErrorScopeCallbackInfo, std::tuple<PopErrorScopeStatus, ErrorType, StringView>> {
+    using Result = std::tuple<PopErrorScopeStatus, ErrorType, StringView>;
+    static Result Convert(WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message) {
+        return std::make_tuple(static_cast<PopErrorScopeStatus>(status), static_cast<ErrorType>(type), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPUQueueWorkDoneCallbackInfo, std::tuple<QueueWorkDoneStatus, StringView>> {
+    using Result = std::tuple<QueueWorkDoneStatus, StringView>;
+    static Result Convert(WGPUQueueWorkDoneStatus status, WGPUStringView message) {
+        return std::make_tuple(static_cast<QueueWorkDoneStatus>(status), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPURequestAdapterCallbackInfo, std::tuple<RequestAdapterStatus, Adapter, StringView>> {
+    using Result = std::tuple<RequestAdapterStatus, Adapter, StringView>;
+    static Result Convert(WGPURequestAdapterStatus status, WGPUAdapter adapter, WGPUStringView message) {
+        return std::make_tuple(static_cast<RequestAdapterStatus>(status), Adapter::Acquire(adapter), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPURequestDeviceCallbackInfo, std::tuple<RequestDeviceStatus, Device, StringView>> {
+    using Result = std::tuple<RequestDeviceStatus, Device, StringView>;
+    static Result Convert(WGPURequestDeviceStatus status, WGPUDevice device, WGPUStringView message) {
+        return std::make_tuple(static_cast<RequestDeviceStatus>(status), Device::Acquire(device), StringView {
+    message.data,
+    message.length
+});
+    }
+};
+template <>
+struct CArgConverter<WGPUDeviceLostCallbackInfo,
+                     std::tuple<const Device&, DeviceLostReason, StringView>> {
+    using Result = std::tuple<const Device&, DeviceLostReason, StringView>;
+    static Result Convert(WGPUDevice const* device,
+                          WGPUDeviceLostReason reason,
+                          WGPUStringView message) {
+        return std::make_tuple(std::cref(*reinterpret_cast<const Device*>(device)),
+                               static_cast<DeviceLostReason>(reason), message);
+    }
+};
+template <>
+struct CArgConverter<WGPUUncapturedErrorCallbackInfo,
+                     std::tuple<const Device&, ErrorType, StringView>> {
+    using Result = std::tuple<const Device&, ErrorType, StringView>;
+    static Result Convert(WGPUDevice const* device, WGPUErrorType type, WGPUStringView message) {
+        return std::make_tuple(std::cref(*reinterpret_cast<const Device*>(device)),
+                               static_cast<ErrorType>(type), message);
+    }
+};
+
+// The CallbackHelper struct implements the static functions needed to convert the base C callbacks
+// into the user provided C++ callbacks. More than anything, it handles converting the real C
+// callback arguments (i.e. not the userdata pointers we use internally) to C++ arguments, and
+// casts the userdata pointers appropriately to ensure that everything is typed.
+template <typename CInfoT, typename CppF, typename CArgsTuple, typename Indices>
+struct CallbackHelperImpl;
+template <typename CInfoT, typename CppF, typename... CArgs, std::size_t... Is>
+struct CallbackHelperImpl<CInfoT, CppF, std::tuple<CArgs...>, std::index_sequence<Is...>> {
+    // Implementation for callbacks without an additional typed argument. We support capturing
+    // lambdas if users can specify a callback mode in this case and make an allocation.
+    static void Call(std::tuple_element_t<Is, std::tuple<CArgs...>>... cArgs,
+                     void* callbackParam, void*) {
+        using CppFTraits = CppFTraits<CppF>;
+        using Converter = CArgConverter<CInfoT, typename CppFTraits::BaseArgsTuple>;
+
+        if constexpr (CppFTraits::capturing) {
+            std::unique_ptr<CppF> callback(reinterpret_cast<CppF*>(callbackParam));
+            std::apply(*callback, Converter::Convert(cArgs...));
+        } else {
+            auto callback = reinterpret_cast<typename CppFTraits::PtrT>(callbackParam);
+            std::apply(callback, Converter::Convert(cArgs...));
+        }
+    }
 
-    inline DeviceDescriptor();
-    struct Init;
-    inline DeviceDescriptor(Init&& init);
+    // Implementation for callbacks where the user specifies an additional typed argument. We do
+    // not support capturing lambdas in this case since the user is already providing a typed
+    // argument and would make more sense for any other state to be capturing by that argument
+    // instead.
+    template <typename T>
+    static void Call(std::tuple_element_t<Is, std::tuple<CArgs...>>... cArgs,
+                     void* callbackParam, void* userdataParam) {
+        using CppFTraits = CppFTraits<CppF, T>;
+        using Converter = CArgConverter<CInfoT, typename CppFTraits::BaseArgsTuple>;
+
+        auto callback = reinterpret_cast<typename CppFTraits::PtrT>(callbackParam);
+        auto param = std::make_tuple(static_cast<T>(userdataParam));
+        std::apply(callback, std::tuple_cat(Converter::Convert(cArgs...), param));
+    }
+};
+template <typename CInfoT, typename F, typename CbT>
+struct CallbackHelper;
+template <typename CInfoT, typename F, typename... CArgs>
+struct CallbackHelper<CInfoT, F, void(*)(CArgs...)> {
+    static constexpr size_t NumCArgs = sizeof...(CArgs);
+    using CArgsTuple = std::tuple<CArgs...>;
+    static_assert(NumCArgs >= 2, "C Function pointers must have two void* trailing arguments.");
+    static_assert(
+        std::is_same_v<std::tuple_element_t<NumCArgs - 1, CArgsTuple>, void*>,
+        "C Function pointer's last argument must be void*."
+    );
+    static_assert(
+        std::is_same_v<std::tuple_element_t<NumCArgs - 2, CArgsTuple>, void*>,
+        "C Function pointer's second to last argument must be void*."
+    );
+
+    using Impl = CallbackHelperImpl<CInfoT, F, CArgsTuple, std::make_index_sequence<NumCArgs - 2>>;
+    static void Call(CArgs... args) {
+        Impl::Call(std::forward<CArgs>(args)...);
+    }
+    template <typename T>
+    static void Call(CArgs... args) {
+        Impl::template Call<T>(std::forward<CArgs>(args)...);
+    }
+};
+
+// The CallbackInfoHelper provides a utility to create a C CallbackInfo struct type from a C++
+// callback. This allows us to de-duplicates the logic used for WebGPU structs that have
+// CallbackInfo members and WebGPU API functions that return a Future.
+template <typename CInfoT, typename F>
+struct CallbackInfoHelper {
+    static CInfoT Create(F lambda) {
+        CInfoT info = {};
+        if constexpr (CppFTraits<F>::capturing) {
+            if constexpr (requires(CInfoT x) { x.mode; }) {
+                // If we have a mode argument, then the callback is guaranteed to be called only
+                // once so we can support it by moving it and making an allocation for it.
+                std::unique_ptr<F> alloc = std::make_unique<F>(std::move(lambda));
+                info.userdata1 = reinterpret_cast<void*>(alloc.release());
+            } else {
+                static_assert(
+                    false, "capturing lambdas aren't supported for repeatable callbacks"
+                );
+            }
+        } else {
+            // Otherwise, if the lambda is not capturing, that means we can refer to it as a
+            // pointer directly.
+            info.userdata1 = reinterpret_cast<void*>(+lambda);
+        }
+        info.callback = CallbackHelper<CInfoT, F, decltype(CInfoT::callback)>::Call;
+        info.userdata2 = nullptr;
+        return info;
+    }
 
-    template <typename F, typename T,
-              typename Cb = DeviceLostCallback<T>,
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*>>>
-    void SetDeviceLostCallback(CallbackMode callbackMode, F callback, T userdata);
-    template <typename L,
-              typename Cb = DeviceLostCallback<>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb>>>
-    void SetDeviceLostCallback(CallbackMode callbackMode, L callback);
-
-    template <typename F, typename T,
-              typename Cb = UncapturedErrorCallback<T>,
-              typename = std::enable_if_t<std::is_convertible_v<F, Cb*>>>
-    void SetUncapturedErrorCallback(F callback, T userdata);
-    template <typename L,
-              typename Cb = UncapturedErrorCallback<>,
-              typename = std::enable_if_t<std::is_convertible_v<L, Cb>>>
-    void SetUncapturedErrorCallback(L callback);
+    template <typename T>
+    requires (!CppFTraits<F>::capturing)
+    static CInfoT Create(F lambda, T userdata) {
+        CInfoT info = {};
+        info.callback = CallbackHelper<CInfoT, F, decltype(CInfoT::callback)>::template Call<T>;
+        info.userdata1 = reinterpret_cast<void*>(+lambda);
+        info.userdata2 = userdata;
+        return info;
+    }
 };
 
+}  // namespace detail
+
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic push
 // error: 'offsetof' within non-standard-layout type 'wgpu::XXX' is conditionally-supported
@@ -4355,14 +4522,14 @@ struct DeviceDescriptor : protected detail::DeviceDescriptor {
 
 // AdapterPropertiesD3D implementation
 AdapterPropertiesD3D::AdapterPropertiesD3D()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesD3D } {}
+: ChainedStructOut { nullptr, SType::AdapterPropertiesD3D } {}
 struct AdapterPropertiesD3D::Init {
     ChainedStructOut *  nextInChain;
     uint32_t shaderModel;
 };
-AdapterPropertiesD3D::AdapterPropertiesD3D(AdapterPropertiesD3D::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesD3D }, 
-    shaderModel(std::move(init.shaderModel)){}
+AdapterPropertiesD3D::AdapterPropertiesD3D(AdapterPropertiesD3D::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::AdapterPropertiesD3D },
+    shaderModel(std::move(init.shaderModel)) {}
 
 AdapterPropertiesD3D::operator const WGPUAdapterPropertiesD3D&() const noexcept {
     return *reinterpret_cast<const WGPUAdapterPropertiesD3D*>(this);
@@ -4373,44 +4540,56 @@ static_assert(alignof(AdapterPropertiesD3D) == alignof(WGPUAdapterPropertiesD3D)
 static_assert(offsetof(AdapterPropertiesD3D, shaderModel) == offsetof(WGPUAdapterPropertiesD3D, shaderModel),
         "offsetof mismatch for AdapterPropertiesD3D::shaderModel");
 
-// AdapterPropertiesExplicitComputeSubgroupSizeConfigs implementation
-AdapterPropertiesExplicitComputeSubgroupSizeConfigs::AdapterPropertiesExplicitComputeSubgroupSizeConfigs()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesExplicitComputeSubgroupSizeConfigs } {}
-struct AdapterPropertiesExplicitComputeSubgroupSizeConfigs::Init {
+// AdapterPropertiesDrm implementation
+AdapterPropertiesDrm::AdapterPropertiesDrm()
+: ChainedStructOut { nullptr, SType::AdapterPropertiesDrm } {}
+struct AdapterPropertiesDrm::Init {
     ChainedStructOut *  nextInChain;
-    uint32_t minExplicitComputeSubgroupSize;
-    uint32_t maxExplicitComputeSubgroupSize;
-    uint32_t maxComputeWorkgroupSubgroups;
-};
-AdapterPropertiesExplicitComputeSubgroupSizeConfigs::AdapterPropertiesExplicitComputeSubgroupSizeConfigs(AdapterPropertiesExplicitComputeSubgroupSizeConfigs::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesExplicitComputeSubgroupSizeConfigs }, 
-    minExplicitComputeSubgroupSize(std::move(init.minExplicitComputeSubgroupSize)), 
-    maxExplicitComputeSubgroupSize(std::move(init.maxExplicitComputeSubgroupSize)), 
-    maxComputeWorkgroupSubgroups(std::move(init.maxComputeWorkgroupSubgroups)){}
-
-AdapterPropertiesExplicitComputeSubgroupSizeConfigs::operator const WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs&() const noexcept {
-    return *reinterpret_cast<const WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs*>(this);
-}
-
-static_assert(sizeof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs) == sizeof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs), "sizeof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs");
-static_assert(alignof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs) == alignof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs), "alignof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs");
-static_assert(offsetof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs, minExplicitComputeSubgroupSize) == offsetof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, minExplicitComputeSubgroupSize),
-        "offsetof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs::minExplicitComputeSubgroupSize");
-static_assert(offsetof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxExplicitComputeSubgroupSize) == offsetof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxExplicitComputeSubgroupSize),
-        "offsetof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs::maxExplicitComputeSubgroupSize");
-static_assert(offsetof(AdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxComputeWorkgroupSubgroups) == offsetof(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, maxComputeWorkgroupSubgroups),
-        "offsetof mismatch for AdapterPropertiesExplicitComputeSubgroupSizeConfigs::maxComputeWorkgroupSubgroups");
+    Bool hasPrimary = false;
+    Bool hasRender = false;
+    uint64_t primaryMajor = 0;
+    uint64_t primaryMinor = 0;
+    uint64_t renderMajor = 0;
+    uint64_t renderMinor = 0;
+};
+AdapterPropertiesDrm::AdapterPropertiesDrm(AdapterPropertiesDrm::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::AdapterPropertiesDrm },
+    hasPrimary(std::move(init.hasPrimary)),
+    hasRender(std::move(init.hasRender)),
+    primaryMajor(std::move(init.primaryMajor)),
+    primaryMinor(std::move(init.primaryMinor)),
+    renderMajor(std::move(init.renderMajor)),
+    renderMinor(std::move(init.renderMinor)) {}
+
+AdapterPropertiesDrm::operator const WGPUAdapterPropertiesDrm&() const noexcept {
+    return *reinterpret_cast<const WGPUAdapterPropertiesDrm*>(this);
+}
+
+static_assert(sizeof(AdapterPropertiesDrm) == sizeof(WGPUAdapterPropertiesDrm), "sizeof mismatch for AdapterPropertiesDrm");
+static_assert(alignof(AdapterPropertiesDrm) == alignof(WGPUAdapterPropertiesDrm), "alignof mismatch for AdapterPropertiesDrm");
+static_assert(offsetof(AdapterPropertiesDrm, hasPrimary) == offsetof(WGPUAdapterPropertiesDrm, hasPrimary),
+        "offsetof mismatch for AdapterPropertiesDrm::hasPrimary");
+static_assert(offsetof(AdapterPropertiesDrm, hasRender) == offsetof(WGPUAdapterPropertiesDrm, hasRender),
+        "offsetof mismatch for AdapterPropertiesDrm::hasRender");
+static_assert(offsetof(AdapterPropertiesDrm, primaryMajor) == offsetof(WGPUAdapterPropertiesDrm, primaryMajor),
+        "offsetof mismatch for AdapterPropertiesDrm::primaryMajor");
+static_assert(offsetof(AdapterPropertiesDrm, primaryMinor) == offsetof(WGPUAdapterPropertiesDrm, primaryMinor),
+        "offsetof mismatch for AdapterPropertiesDrm::primaryMinor");
+static_assert(offsetof(AdapterPropertiesDrm, renderMajor) == offsetof(WGPUAdapterPropertiesDrm, renderMajor),
+        "offsetof mismatch for AdapterPropertiesDrm::renderMajor");
+static_assert(offsetof(AdapterPropertiesDrm, renderMinor) == offsetof(WGPUAdapterPropertiesDrm, renderMinor),
+        "offsetof mismatch for AdapterPropertiesDrm::renderMinor");
 
 // AdapterPropertiesVk implementation
 AdapterPropertiesVk::AdapterPropertiesVk()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesVk } {}
+: ChainedStructOut { nullptr, SType::AdapterPropertiesVk } {}
 struct AdapterPropertiesVk::Init {
     ChainedStructOut *  nextInChain;
     uint32_t driverVersion;
 };
-AdapterPropertiesVk::AdapterPropertiesVk(AdapterPropertiesVk::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesVk }, 
-    driverVersion(std::move(init.driverVersion)){}
+AdapterPropertiesVk::AdapterPropertiesVk(AdapterPropertiesVk::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::AdapterPropertiesVk },
+    driverVersion(std::move(init.driverVersion)) {}
 
 AdapterPropertiesVk::operator const WGPUAdapterPropertiesVk&() const noexcept {
     return *reinterpret_cast<const WGPUAdapterPropertiesVk*>(this);
@@ -4423,14 +4602,14 @@ static_assert(offsetof(AdapterPropertiesVk, driverVersion) == offsetof(WGPUAdapt
 
 // AdapterPropertiesWGPU implementation
 AdapterPropertiesWGPU::AdapterPropertiesWGPU()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesWGPU } {}
+: ChainedStructOut { nullptr, SType::AdapterPropertiesWGPU } {}
 struct AdapterPropertiesWGPU::Init {
     ChainedStructOut *  nextInChain;
     BackendType backendType = BackendType::Undefined;
 };
-AdapterPropertiesWGPU::AdapterPropertiesWGPU(AdapterPropertiesWGPU::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesWGPU }, 
-    backendType(std::move(init.backendType)){}
+AdapterPropertiesWGPU::AdapterPropertiesWGPU(AdapterPropertiesWGPU::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::AdapterPropertiesWGPU },
+    backendType(std::move(init.backendType)) {}
 
 AdapterPropertiesWGPU::operator const WGPUAdapterPropertiesWGPU&() const noexcept {
     return *reinterpret_cast<const WGPUAdapterPropertiesWGPU*>(this);
@@ -4496,18 +4675,18 @@ static_assert(offsetof(BufferBindingLayout, minBindingSize) == offsetof(WGPUBuff
 
 // BufferHostMappedPointer implementation
 BufferHostMappedPointer::BufferHostMappedPointer()
-  : ChainedStruct { nullptr, SType::BufferHostMappedPointer } {}
+: ChainedStruct { nullptr, SType::BufferHostMappedPointer } {}
 struct BufferHostMappedPointer::Init {
     ChainedStruct * const nextInChain;
     void * pointer;
     Callback disposeCallback;
     void * userdata;
 };
-BufferHostMappedPointer::BufferHostMappedPointer(BufferHostMappedPointer::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::BufferHostMappedPointer }, 
-    pointer(std::move(init.pointer)), 
-    disposeCallback(std::move(init.disposeCallback)), 
-    userdata(std::move(init.userdata)){}
+BufferHostMappedPointer::BufferHostMappedPointer(BufferHostMappedPointer::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::BufferHostMappedPointer },
+    pointer(std::move(init.pointer)),
+    disposeCallback(std::move(init.disposeCallback)),
+    userdata(std::move(init.userdata)) {}
 
 BufferHostMappedPointer::operator const WGPUBufferHostMappedPointer&() const noexcept {
     return *reinterpret_cast<const WGPUBufferHostMappedPointer*>(this);
@@ -4539,16 +4718,35 @@ static_assert(offsetof(Color, b) == offsetof(WGPUColor, b),
 static_assert(offsetof(Color, a) == offsetof(WGPUColor, a),
         "offsetof mismatch for Color::a");
 
+// ColorSpaceDawn implementation
+
+ColorSpaceDawn::operator const WGPUColorSpaceDawn&() const noexcept {
+    return *reinterpret_cast<const WGPUColorSpaceDawn*>(this);
+}
+
+static_assert(sizeof(ColorSpaceDawn) == sizeof(WGPUColorSpaceDawn), "sizeof mismatch for ColorSpaceDawn");
+static_assert(alignof(ColorSpaceDawn) == alignof(WGPUColorSpaceDawn), "alignof mismatch for ColorSpaceDawn");
+static_assert(offsetof(ColorSpaceDawn, nextInChain) == offsetof(WGPUColorSpaceDawn, nextInChain),
+        "offsetof mismatch for ColorSpaceDawn::nextInChain");
+static_assert(offsetof(ColorSpaceDawn, primaries) == offsetof(WGPUColorSpaceDawn, primaries),
+        "offsetof mismatch for ColorSpaceDawn::primaries");
+static_assert(offsetof(ColorSpaceDawn, transfer) == offsetof(WGPUColorSpaceDawn, transfer),
+        "offsetof mismatch for ColorSpaceDawn::transfer");
+static_assert(offsetof(ColorSpaceDawn, yCbCrRange) == offsetof(WGPUColorSpaceDawn, yCbCrRange),
+        "offsetof mismatch for ColorSpaceDawn::yCbCrRange");
+static_assert(offsetof(ColorSpaceDawn, yCbCrMatrix) == offsetof(WGPUColorSpaceDawn, yCbCrMatrix),
+        "offsetof mismatch for ColorSpaceDawn::yCbCrMatrix");
+
 // ColorTargetStateExpandResolveTextureDawn implementation
 ColorTargetStateExpandResolveTextureDawn::ColorTargetStateExpandResolveTextureDawn()
-  : ChainedStruct { nullptr, SType::ColorTargetStateExpandResolveTextureDawn } {}
+: ChainedStruct { nullptr, SType::ColorTargetStateExpandResolveTextureDawn } {}
 struct ColorTargetStateExpandResolveTextureDawn::Init {
     ChainedStruct * const nextInChain;
     Bool enabled = false;
 };
-ColorTargetStateExpandResolveTextureDawn::ColorTargetStateExpandResolveTextureDawn(ColorTargetStateExpandResolveTextureDawn::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::ColorTargetStateExpandResolveTextureDawn }, 
-    enabled(std::move(init.enabled)){}
+ColorTargetStateExpandResolveTextureDawn::ColorTargetStateExpandResolveTextureDawn(ColorTargetStateExpandResolveTextureDawn::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::ColorTargetStateExpandResolveTextureDawn },
+    enabled(std::move(init.enabled)) {}
 
 ColorTargetStateExpandResolveTextureDawn::operator const WGPUColorTargetStateExpandResolveTextureDawn&() const noexcept {
     return *reinterpret_cast<const WGPUColorTargetStateExpandResolveTextureDawn*>(this);
@@ -4574,7 +4772,7 @@ static_assert(offsetof(CommandBufferDescriptor, label) == offsetof(WGPUCommandBu
 
 // CompatibilityModeLimits implementation
 CompatibilityModeLimits::CompatibilityModeLimits()
-  : ChainedStructOut { nullptr, SType::CompatibilityModeLimits } {}
+: ChainedStructOut { nullptr, SType::CompatibilityModeLimits } {}
 struct CompatibilityModeLimits::Init {
     ChainedStructOut *  nextInChain;
     uint32_t maxStorageBuffersInVertexStage = kLimitU32Undefined;
@@ -4582,12 +4780,12 @@ struct CompatibilityModeLimits::Init {
     uint32_t maxStorageBuffersInFragmentStage = kLimitU32Undefined;
     uint32_t maxStorageTexturesInFragmentStage = kLimitU32Undefined;
 };
-CompatibilityModeLimits::CompatibilityModeLimits(CompatibilityModeLimits::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::CompatibilityModeLimits }, 
-    maxStorageBuffersInVertexStage(std::move(init.maxStorageBuffersInVertexStage)), 
-    maxStorageTexturesInVertexStage(std::move(init.maxStorageTexturesInVertexStage)), 
-    maxStorageBuffersInFragmentStage(std::move(init.maxStorageBuffersInFragmentStage)), 
-    maxStorageTexturesInFragmentStage(std::move(init.maxStorageTexturesInFragmentStage)){}
+CompatibilityModeLimits::CompatibilityModeLimits(CompatibilityModeLimits::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::CompatibilityModeLimits },
+    maxStorageBuffersInVertexStage(std::move(init.maxStorageBuffersInVertexStage)),
+    maxStorageTexturesInVertexStage(std::move(init.maxStorageTexturesInVertexStage)),
+    maxStorageBuffersInFragmentStage(std::move(init.maxStorageBuffersInFragmentStage)),
+    maxStorageTexturesInFragmentStage(std::move(init.maxStorageTexturesInFragmentStage)) {}
 
 CompatibilityModeLimits::operator const WGPUCompatibilityModeLimits&() const noexcept {
     return *reinterpret_cast<const WGPUCompatibilityModeLimits*>(this);
@@ -4648,14 +4846,14 @@ static_assert(offsetof(CopyTextureForBrowserOptions, internalUsage) == offsetof(
 
 // DawnAdapterPropertiesPowerPreference implementation
 DawnAdapterPropertiesPowerPreference::DawnAdapterPropertiesPowerPreference()
-  : ChainedStructOut { nullptr, SType::DawnAdapterPropertiesPowerPreference } {}
+: ChainedStructOut { nullptr, SType::DawnAdapterPropertiesPowerPreference } {}
 struct DawnAdapterPropertiesPowerPreference::Init {
     ChainedStructOut *  nextInChain;
     PowerPreference powerPreference = PowerPreference::Undefined;
 };
-DawnAdapterPropertiesPowerPreference::DawnAdapterPropertiesPowerPreference(DawnAdapterPropertiesPowerPreference::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::DawnAdapterPropertiesPowerPreference }, 
-    powerPreference(std::move(init.powerPreference)){}
+DawnAdapterPropertiesPowerPreference::DawnAdapterPropertiesPowerPreference(DawnAdapterPropertiesPowerPreference::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::DawnAdapterPropertiesPowerPreference },
+    powerPreference(std::move(init.powerPreference)) {}
 
 DawnAdapterPropertiesPowerPreference::operator const WGPUDawnAdapterPropertiesPowerPreference&() const noexcept {
     return *reinterpret_cast<const WGPUDawnAdapterPropertiesPowerPreference*>(this);
@@ -4668,14 +4866,14 @@ static_assert(offsetof(DawnAdapterPropertiesPowerPreference, powerPreference) ==
 
 // DawnBufferDescriptorErrorInfoFromWireClient implementation
 DawnBufferDescriptorErrorInfoFromWireClient::DawnBufferDescriptorErrorInfoFromWireClient()
-  : ChainedStruct { nullptr, SType::DawnBufferDescriptorErrorInfoFromWireClient } {}
+: ChainedStruct { nullptr, SType::DawnBufferDescriptorErrorInfoFromWireClient } {}
 struct DawnBufferDescriptorErrorInfoFromWireClient::Init {
     ChainedStruct * const nextInChain;
     Bool outOfMemory = false;
 };
-DawnBufferDescriptorErrorInfoFromWireClient::DawnBufferDescriptorErrorInfoFromWireClient(DawnBufferDescriptorErrorInfoFromWireClient::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnBufferDescriptorErrorInfoFromWireClient }, 
-    outOfMemory(std::move(init.outOfMemory)){}
+DawnBufferDescriptorErrorInfoFromWireClient::DawnBufferDescriptorErrorInfoFromWireClient(DawnBufferDescriptorErrorInfoFromWireClient::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnBufferDescriptorErrorInfoFromWireClient },
+    outOfMemory(std::move(init.outOfMemory)) {}
 
 DawnBufferDescriptorErrorInfoFromWireClient::operator const WGPUDawnBufferDescriptorErrorInfoFromWireClient&() const noexcept {
     return *reinterpret_cast<const WGPUDawnBufferDescriptorErrorInfoFromWireClient*>(this);
@@ -4688,7 +4886,7 @@ static_assert(offsetof(DawnBufferDescriptorErrorInfoFromWireClient, outOfMemory)
 
 // DawnCacheDeviceDescriptor implementation
 DawnCacheDeviceDescriptor::DawnCacheDeviceDescriptor()
-  : ChainedStruct { nullptr, SType::DawnCacheDeviceDescriptor } {}
+: ChainedStruct { nullptr, SType::DawnCacheDeviceDescriptor } {}
 struct DawnCacheDeviceDescriptor::Init {
     ChainedStruct * const nextInChain;
     StringView isolationKey = {};
@@ -4696,12 +4894,12 @@ struct DawnCacheDeviceDescriptor::Init {
     DawnStoreCacheDataFunction storeDataFunction = nullptr;
     void * functionUserdata = nullptr;
 };
-DawnCacheDeviceDescriptor::DawnCacheDeviceDescriptor(DawnCacheDeviceDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnCacheDeviceDescriptor }, 
-    isolationKey(std::move(init.isolationKey)), 
-    loadDataFunction(std::move(init.loadDataFunction)), 
-    storeDataFunction(std::move(init.storeDataFunction)), 
-    functionUserdata(std::move(init.functionUserdata)){}
+DawnCacheDeviceDescriptor::DawnCacheDeviceDescriptor(DawnCacheDeviceDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnCacheDeviceDescriptor },
+    isolationKey(std::move(init.isolationKey)),
+    loadDataFunction(std::move(init.loadDataFunction)),
+    storeDataFunction(std::move(init.storeDataFunction)),
+    functionUserdata(std::move(init.functionUserdata)) {}
 
 DawnCacheDeviceDescriptor::operator const WGPUDawnCacheDeviceDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnCacheDeviceDescriptor*>(this);
@@ -4720,18 +4918,18 @@ static_assert(offsetof(DawnCacheDeviceDescriptor, functionUserdata) == offsetof(
 
 // DawnCompilationMessageUtf16 implementation
 DawnCompilationMessageUtf16::DawnCompilationMessageUtf16()
-  : ChainedStruct { nullptr, SType::DawnCompilationMessageUtf16 } {}
+: ChainedStruct { nullptr, SType::DawnCompilationMessageUtf16 } {}
 struct DawnCompilationMessageUtf16::Init {
     ChainedStruct * const nextInChain;
     uint64_t linePos;
     uint64_t offset;
     uint64_t length;
 };
-DawnCompilationMessageUtf16::DawnCompilationMessageUtf16(DawnCompilationMessageUtf16::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnCompilationMessageUtf16 }, 
-    linePos(std::move(init.linePos)), 
-    offset(std::move(init.offset)), 
-    length(std::move(init.length)){}
+DawnCompilationMessageUtf16::DawnCompilationMessageUtf16(DawnCompilationMessageUtf16::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnCompilationMessageUtf16 },
+    linePos(std::move(init.linePos)),
+    offset(std::move(init.offset)),
+    length(std::move(init.length)) {}
 
 DawnCompilationMessageUtf16::operator const WGPUDawnCompilationMessageUtf16&() const noexcept {
     return *reinterpret_cast<const WGPUDawnCompilationMessageUtf16*>(this);
@@ -4748,14 +4946,14 @@ static_assert(offsetof(DawnCompilationMessageUtf16, length) == offsetof(WGPUDawn
 
 // DawnConsumeAdapterDescriptor implementation
 DawnConsumeAdapterDescriptor::DawnConsumeAdapterDescriptor()
-  : ChainedStruct { nullptr, SType::DawnConsumeAdapterDescriptor } {}
+: ChainedStruct { nullptr, SType::DawnConsumeAdapterDescriptor } {}
 struct DawnConsumeAdapterDescriptor::Init {
     ChainedStruct * const nextInChain;
     Bool consumeAdapter = false;
 };
-DawnConsumeAdapterDescriptor::DawnConsumeAdapterDescriptor(DawnConsumeAdapterDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnConsumeAdapterDescriptor }, 
-    consumeAdapter(std::move(init.consumeAdapter)){}
+DawnConsumeAdapterDescriptor::DawnConsumeAdapterDescriptor(DawnConsumeAdapterDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnConsumeAdapterDescriptor },
+    consumeAdapter(std::move(init.consumeAdapter)) {}
 
 DawnConsumeAdapterDescriptor::operator const WGPUDawnConsumeAdapterDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnConsumeAdapterDescriptor*>(this);
@@ -4768,14 +4966,14 @@ static_assert(offsetof(DawnConsumeAdapterDescriptor, consumeAdapter) == offsetof
 
 // DawnDeviceAllocatorControl implementation
 DawnDeviceAllocatorControl::DawnDeviceAllocatorControl()
-  : ChainedStruct { nullptr, SType::DawnDeviceAllocatorControl } {}
+: ChainedStruct { nullptr, SType::DawnDeviceAllocatorControl } {}
 struct DawnDeviceAllocatorControl::Init {
     ChainedStruct * const nextInChain;
     size_t allocatorHeapBlockSize = 0;
 };
-DawnDeviceAllocatorControl::DawnDeviceAllocatorControl(DawnDeviceAllocatorControl::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnDeviceAllocatorControl }, 
-    allocatorHeapBlockSize(std::move(init.allocatorHeapBlockSize)){}
+DawnDeviceAllocatorControl::DawnDeviceAllocatorControl(DawnDeviceAllocatorControl::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnDeviceAllocatorControl },
+    allocatorHeapBlockSize(std::move(init.allocatorHeapBlockSize)) {}
 
 DawnDeviceAllocatorControl::operator const WGPUDawnDeviceAllocatorControl&() const noexcept {
     return *reinterpret_cast<const WGPUDawnDeviceAllocatorControl*>(this);
@@ -4801,14 +4999,14 @@ static_assert(offsetof(DawnDrmFormatProperties, modifierPlaneCount) == offsetof(
 
 // DawnEncoderInternalUsageDescriptor implementation
 DawnEncoderInternalUsageDescriptor::DawnEncoderInternalUsageDescriptor()
-  : ChainedStruct { nullptr, SType::DawnEncoderInternalUsageDescriptor } {}
+: ChainedStruct { nullptr, SType::DawnEncoderInternalUsageDescriptor } {}
 struct DawnEncoderInternalUsageDescriptor::Init {
     ChainedStruct * const nextInChain;
     Bool useInternalUsages = false;
 };
-DawnEncoderInternalUsageDescriptor::DawnEncoderInternalUsageDescriptor(DawnEncoderInternalUsageDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnEncoderInternalUsageDescriptor }, 
-    useInternalUsages(std::move(init.useInternalUsages)){}
+DawnEncoderInternalUsageDescriptor::DawnEncoderInternalUsageDescriptor(DawnEncoderInternalUsageDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnEncoderInternalUsageDescriptor },
+    useInternalUsages(std::move(init.useInternalUsages)) {}
 
 DawnEncoderInternalUsageDescriptor::operator const WGPUDawnEncoderInternalUsageDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnEncoderInternalUsageDescriptor*>(this);
@@ -4821,18 +5019,18 @@ static_assert(offsetof(DawnEncoderInternalUsageDescriptor, useInternalUsages) ==
 
 // DawnFakeBufferOOMForTesting implementation
 DawnFakeBufferOOMForTesting::DawnFakeBufferOOMForTesting()
-  : ChainedStruct { nullptr, SType::DawnFakeBufferOOMForTesting } {}
+: ChainedStruct { nullptr, SType::DawnFakeBufferOOMForTesting } {}
 struct DawnFakeBufferOOMForTesting::Init {
     ChainedStruct * const nextInChain;
     Bool fakeOOMAtWireClientMap;
     Bool fakeOOMAtNativeMap;
     Bool fakeOOMAtDevice;
 };
-DawnFakeBufferOOMForTesting::DawnFakeBufferOOMForTesting(DawnFakeBufferOOMForTesting::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnFakeBufferOOMForTesting }, 
-    fakeOOMAtWireClientMap(std::move(init.fakeOOMAtWireClientMap)), 
-    fakeOOMAtNativeMap(std::move(init.fakeOOMAtNativeMap)), 
-    fakeOOMAtDevice(std::move(init.fakeOOMAtDevice)){}
+DawnFakeBufferOOMForTesting::DawnFakeBufferOOMForTesting(DawnFakeBufferOOMForTesting::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnFakeBufferOOMForTesting },
+    fakeOOMAtWireClientMap(std::move(init.fakeOOMAtWireClientMap)),
+    fakeOOMAtNativeMap(std::move(init.fakeOOMAtNativeMap)),
+    fakeOOMAtDevice(std::move(init.fakeOOMAtDevice)) {}
 
 DawnFakeBufferOOMForTesting::operator const WGPUDawnFakeBufferOOMForTesting&() const noexcept {
     return *reinterpret_cast<const WGPUDawnFakeBufferOOMForTesting*>(this);
@@ -4849,12 +5047,12 @@ static_assert(offsetof(DawnFakeBufferOOMForTesting, fakeOOMAtDevice) == offsetof
 
 // DawnFakeDeviceInitializeErrorForTesting implementation
 DawnFakeDeviceInitializeErrorForTesting::DawnFakeDeviceInitializeErrorForTesting()
-  : ChainedStruct { nullptr, SType::DawnFakeDeviceInitializeErrorForTesting } {}
+: ChainedStruct { nullptr, SType::DawnFakeDeviceInitializeErrorForTesting } {}
 struct DawnFakeDeviceInitializeErrorForTesting::Init {
     ChainedStruct * const nextInChain;
 };
-DawnFakeDeviceInitializeErrorForTesting::DawnFakeDeviceInitializeErrorForTesting(DawnFakeDeviceInitializeErrorForTesting::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnFakeDeviceInitializeErrorForTesting }{}
+DawnFakeDeviceInitializeErrorForTesting::DawnFakeDeviceInitializeErrorForTesting(DawnFakeDeviceInitializeErrorForTesting::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnFakeDeviceInitializeErrorForTesting } {}
 
 DawnFakeDeviceInitializeErrorForTesting::operator const WGPUDawnFakeDeviceInitializeErrorForTesting&() const noexcept {
     return *reinterpret_cast<const WGPUDawnFakeDeviceInitializeErrorForTesting*>(this);
@@ -4865,14 +5063,14 @@ static_assert(alignof(DawnFakeDeviceInitializeErrorForTesting) == alignof(WGPUDa
 
 // DawnHostMappedPointerLimits implementation
 DawnHostMappedPointerLimits::DawnHostMappedPointerLimits()
-  : ChainedStructOut { nullptr, SType::DawnHostMappedPointerLimits } {}
+: ChainedStructOut { nullptr, SType::DawnHostMappedPointerLimits } {}
 struct DawnHostMappedPointerLimits::Init {
     ChainedStructOut *  nextInChain;
     uint32_t hostMappedPointerAlignment = kLimitU32Undefined;
 };
-DawnHostMappedPointerLimits::DawnHostMappedPointerLimits(DawnHostMappedPointerLimits::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::DawnHostMappedPointerLimits }, 
-    hostMappedPointerAlignment(std::move(init.hostMappedPointerAlignment)){}
+DawnHostMappedPointerLimits::DawnHostMappedPointerLimits(DawnHostMappedPointerLimits::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::DawnHostMappedPointerLimits },
+    hostMappedPointerAlignment(std::move(init.hostMappedPointerAlignment)) {}
 
 DawnHostMappedPointerLimits::operator const WGPUDawnHostMappedPointerLimits&() const noexcept {
     return *reinterpret_cast<const WGPUDawnHostMappedPointerLimits*>(this);
@@ -4885,14 +5083,14 @@ static_assert(offsetof(DawnHostMappedPointerLimits, hostMappedPointerAlignment)
 
 // DawnInjectedInvalidSType implementation
 DawnInjectedInvalidSType::DawnInjectedInvalidSType()
-  : ChainedStruct { nullptr, SType::DawnInjectedInvalidSType } {}
+: ChainedStruct { nullptr, SType::DawnInjectedInvalidSType } {}
 struct DawnInjectedInvalidSType::Init {
     ChainedStruct * const nextInChain;
     SType invalidSType = {};
 };
-DawnInjectedInvalidSType::DawnInjectedInvalidSType(DawnInjectedInvalidSType::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnInjectedInvalidSType }, 
-    invalidSType(std::move(init.invalidSType)){}
+DawnInjectedInvalidSType::DawnInjectedInvalidSType(DawnInjectedInvalidSType::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnInjectedInvalidSType },
+    invalidSType(std::move(init.invalidSType)) {}
 
 DawnInjectedInvalidSType::operator const WGPUDawnInjectedInvalidSType&() const noexcept {
     return *reinterpret_cast<const WGPUDawnInjectedInvalidSType*>(this);
@@ -4905,14 +5103,14 @@ static_assert(offsetof(DawnInjectedInvalidSType, invalidSType) == offsetof(WGPUD
 
 // DawnRenderPassSampleCount implementation
 DawnRenderPassSampleCount::DawnRenderPassSampleCount()
-  : ChainedStruct { nullptr, SType::DawnRenderPassSampleCount } {}
+: ChainedStruct { nullptr, SType::DawnRenderPassSampleCount } {}
 struct DawnRenderPassSampleCount::Init {
     ChainedStruct * const nextInChain;
     uint32_t sampleCount = 1;
 };
-DawnRenderPassSampleCount::DawnRenderPassSampleCount(DawnRenderPassSampleCount::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnRenderPassSampleCount }, 
-    sampleCount(std::move(init.sampleCount)){}
+DawnRenderPassSampleCount::DawnRenderPassSampleCount(DawnRenderPassSampleCount::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnRenderPassSampleCount },
+    sampleCount(std::move(init.sampleCount)) {}
 
 DawnRenderPassSampleCount::operator const WGPUDawnRenderPassSampleCount&() const noexcept {
     return *reinterpret_cast<const WGPUDawnRenderPassSampleCount*>(this);
@@ -4925,14 +5123,14 @@ static_assert(offsetof(DawnRenderPassSampleCount, sampleCount) == offsetof(WGPUD
 
 // DawnShaderModuleSPIRVOptionsDescriptor implementation
 DawnShaderModuleSPIRVOptionsDescriptor::DawnShaderModuleSPIRVOptionsDescriptor()
-  : ChainedStruct { nullptr, SType::DawnShaderModuleSPIRVOptionsDescriptor } {}
+: ChainedStruct { nullptr, SType::DawnShaderModuleSPIRVOptionsDescriptor } {}
 struct DawnShaderModuleSPIRVOptionsDescriptor::Init {
     ChainedStruct * const nextInChain;
     Bool allowNonUniformDerivatives = false;
 };
-DawnShaderModuleSPIRVOptionsDescriptor::DawnShaderModuleSPIRVOptionsDescriptor(DawnShaderModuleSPIRVOptionsDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnShaderModuleSPIRVOptionsDescriptor }, 
-    allowNonUniformDerivatives(std::move(init.allowNonUniformDerivatives)){}
+DawnShaderModuleSPIRVOptionsDescriptor::DawnShaderModuleSPIRVOptionsDescriptor(DawnShaderModuleSPIRVOptionsDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnShaderModuleSPIRVOptionsDescriptor },
+    allowNonUniformDerivatives(std::move(init.allowNonUniformDerivatives)) {}
 
 DawnShaderModuleSPIRVOptionsDescriptor::operator const WGPUDawnShaderModuleSPIRVOptionsDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnShaderModuleSPIRVOptionsDescriptor*>(this);
@@ -4945,14 +5143,14 @@ static_assert(offsetof(DawnShaderModuleSPIRVOptionsDescriptor, allowNonUniformDe
 
 // DawnTexelCopyBufferRowAlignmentLimits implementation
 DawnTexelCopyBufferRowAlignmentLimits::DawnTexelCopyBufferRowAlignmentLimits()
-  : ChainedStructOut { nullptr, SType::DawnTexelCopyBufferRowAlignmentLimits } {}
+: ChainedStructOut { nullptr, SType::DawnTexelCopyBufferRowAlignmentLimits } {}
 struct DawnTexelCopyBufferRowAlignmentLimits::Init {
     ChainedStructOut *  nextInChain;
     uint32_t minTexelCopyBufferRowAlignment = kLimitU32Undefined;
 };
-DawnTexelCopyBufferRowAlignmentLimits::DawnTexelCopyBufferRowAlignmentLimits(DawnTexelCopyBufferRowAlignmentLimits::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::DawnTexelCopyBufferRowAlignmentLimits }, 
-    minTexelCopyBufferRowAlignment(std::move(init.minTexelCopyBufferRowAlignment)){}
+DawnTexelCopyBufferRowAlignmentLimits::DawnTexelCopyBufferRowAlignmentLimits(DawnTexelCopyBufferRowAlignmentLimits::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::DawnTexelCopyBufferRowAlignmentLimits },
+    minTexelCopyBufferRowAlignment(std::move(init.minTexelCopyBufferRowAlignment)) {}
 
 DawnTexelCopyBufferRowAlignmentLimits::operator const WGPUDawnTexelCopyBufferRowAlignmentLimits&() const noexcept {
     return *reinterpret_cast<const WGPUDawnTexelCopyBufferRowAlignmentLimits*>(this);
@@ -4965,14 +5163,14 @@ static_assert(offsetof(DawnTexelCopyBufferRowAlignmentLimits, minTexelCopyBuffer
 
 // DawnTextureInternalUsageDescriptor implementation
 DawnTextureInternalUsageDescriptor::DawnTextureInternalUsageDescriptor()
-  : ChainedStruct { nullptr, SType::DawnTextureInternalUsageDescriptor } {}
+: ChainedStruct { nullptr, SType::DawnTextureInternalUsageDescriptor } {}
 struct DawnTextureInternalUsageDescriptor::Init {
     ChainedStruct * const nextInChain;
     TextureUsage internalUsage = TextureUsage::None;
 };
-DawnTextureInternalUsageDescriptor::DawnTextureInternalUsageDescriptor(DawnTextureInternalUsageDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnTextureInternalUsageDescriptor }, 
-    internalUsage(std::move(init.internalUsage)){}
+DawnTextureInternalUsageDescriptor::DawnTextureInternalUsageDescriptor(DawnTextureInternalUsageDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnTextureInternalUsageDescriptor },
+    internalUsage(std::move(init.internalUsage)) {}
 
 DawnTextureInternalUsageDescriptor::operator const WGPUDawnTextureInternalUsageDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnTextureInternalUsageDescriptor*>(this);
@@ -4985,7 +5183,7 @@ static_assert(offsetof(DawnTextureInternalUsageDescriptor, internalUsage) == off
 
 // DawnTogglesDescriptor implementation
 DawnTogglesDescriptor::DawnTogglesDescriptor()
-  : ChainedStruct { nullptr, SType::DawnTogglesDescriptor } {}
+: ChainedStruct { nullptr, SType::DawnTogglesDescriptor } {}
 struct DawnTogglesDescriptor::Init {
     ChainedStruct * const nextInChain;
     size_t enabledToggleCount = 0;
@@ -4993,12 +5191,12 @@ struct DawnTogglesDescriptor::Init {
     size_t disabledToggleCount = 0;
     const char* const * disabledToggles = nullptr;
 };
-DawnTogglesDescriptor::DawnTogglesDescriptor(DawnTogglesDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnTogglesDescriptor }, 
-    enabledToggleCount(std::move(init.enabledToggleCount)), 
-    enabledToggles(std::move(init.enabledToggles)), 
-    disabledToggleCount(std::move(init.disabledToggleCount)), 
-    disabledToggles(std::move(init.disabledToggles)){}
+DawnTogglesDescriptor::DawnTogglesDescriptor(DawnTogglesDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnTogglesDescriptor },
+    enabledToggleCount(std::move(init.enabledToggleCount)),
+    enabledToggles(std::move(init.enabledToggles)),
+    disabledToggleCount(std::move(init.disabledToggleCount)),
+    disabledToggles(std::move(init.disabledToggles)) {}
 
 DawnTogglesDescriptor::operator const WGPUDawnTogglesDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnTogglesDescriptor*>(this);
@@ -5017,16 +5215,16 @@ static_assert(offsetof(DawnTogglesDescriptor, disabledToggles) == offsetof(WGPUD
 
 // DawnWGSLBlocklist implementation
 DawnWGSLBlocklist::DawnWGSLBlocklist()
-  : ChainedStruct { nullptr, SType::DawnWGSLBlocklist } {}
+: ChainedStruct { nullptr, SType::DawnWGSLBlocklist } {}
 struct DawnWGSLBlocklist::Init {
     ChainedStruct * const nextInChain;
     size_t blocklistedFeatureCount = 0;
     const char* const * blocklistedFeatures = nullptr;
 };
-DawnWGSLBlocklist::DawnWGSLBlocklist(DawnWGSLBlocklist::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnWGSLBlocklist }, 
-    blocklistedFeatureCount(std::move(init.blocklistedFeatureCount)), 
-    blocklistedFeatures(std::move(init.blocklistedFeatures)){}
+DawnWGSLBlocklist::DawnWGSLBlocklist(DawnWGSLBlocklist::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnWGSLBlocklist },
+    blocklistedFeatureCount(std::move(init.blocklistedFeatureCount)),
+    blocklistedFeatures(std::move(init.blocklistedFeatures)) {}
 
 DawnWGSLBlocklist::operator const WGPUDawnWGSLBlocklist&() const noexcept {
     return *reinterpret_cast<const WGPUDawnWGSLBlocklist*>(this);
@@ -5041,18 +5239,18 @@ static_assert(offsetof(DawnWGSLBlocklist, blocklistedFeatures) == offsetof(WGPUD
 
 // DawnWireWGSLControl implementation
 DawnWireWGSLControl::DawnWireWGSLControl()
-  : ChainedStruct { nullptr, SType::DawnWireWGSLControl } {}
+: ChainedStruct { nullptr, SType::DawnWireWGSLControl } {}
 struct DawnWireWGSLControl::Init {
     ChainedStruct * const nextInChain;
     Bool enableExperimental = false;
     Bool enableUnsafe = false;
     Bool enableTesting = false;
 };
-DawnWireWGSLControl::DawnWireWGSLControl(DawnWireWGSLControl::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::DawnWireWGSLControl }, 
-    enableExperimental(std::move(init.enableExperimental)), 
-    enableUnsafe(std::move(init.enableUnsafe)), 
-    enableTesting(std::move(init.enableTesting)){}
+DawnWireWGSLControl::DawnWireWGSLControl(DawnWireWGSLControl::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::DawnWireWGSLControl },
+    enableExperimental(std::move(init.enableExperimental)),
+    enableUnsafe(std::move(init.enableUnsafe)),
+    enableTesting(std::move(init.enableTesting)) {}
 
 DawnWireWGSLControl::operator const WGPUDawnWireWGSLControl&() const noexcept {
     return *reinterpret_cast<const WGPUDawnWireWGSLControl*>(this);
@@ -5069,14 +5267,14 @@ static_assert(offsetof(DawnWireWGSLControl, enableTesting) == offsetof(WGPUDawnW
 
 // EmscriptenSurfaceSourceCanvasHTMLSelector implementation
 EmscriptenSurfaceSourceCanvasHTMLSelector::EmscriptenSurfaceSourceCanvasHTMLSelector()
-  : ChainedStruct { nullptr, SType::EmscriptenSurfaceSourceCanvasHTMLSelector } {}
+: ChainedStruct { nullptr, SType::EmscriptenSurfaceSourceCanvasHTMLSelector } {}
 struct EmscriptenSurfaceSourceCanvasHTMLSelector::Init {
     ChainedStruct * const nextInChain;
     StringView selector = {};
 };
-EmscriptenSurfaceSourceCanvasHTMLSelector::EmscriptenSurfaceSourceCanvasHTMLSelector(EmscriptenSurfaceSourceCanvasHTMLSelector::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::EmscriptenSurfaceSourceCanvasHTMLSelector }, 
-    selector(std::move(init.selector)){}
+EmscriptenSurfaceSourceCanvasHTMLSelector::EmscriptenSurfaceSourceCanvasHTMLSelector(EmscriptenSurfaceSourceCanvasHTMLSelector::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::EmscriptenSurfaceSourceCanvasHTMLSelector },
+    selector(std::move(init.selector)) {}
 
 EmscriptenSurfaceSourceCanvasHTMLSelector::operator const WGPUEmscriptenSurfaceSourceCanvasHTMLSelector&() const noexcept {
     return *reinterpret_cast<const WGPUEmscriptenSurfaceSourceCanvasHTMLSelector*>(this);
@@ -5117,14 +5315,14 @@ static_assert(offsetof(Extent3D, depthOrArrayLayers) == offsetof(WGPUExtent3D, d
 
 // ExternalTextureBindingEntry implementation
 ExternalTextureBindingEntry::ExternalTextureBindingEntry()
-  : ChainedStruct { nullptr, SType::ExternalTextureBindingEntry } {}
+: ChainedStruct { nullptr, SType::ExternalTextureBindingEntry } {}
 struct ExternalTextureBindingEntry::Init {
     ChainedStruct * const nextInChain;
     ExternalTexture externalTexture = nullptr;
 };
-ExternalTextureBindingEntry::ExternalTextureBindingEntry(ExternalTextureBindingEntry::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::ExternalTextureBindingEntry }, 
-    externalTexture(std::move(init.externalTexture)){}
+ExternalTextureBindingEntry::ExternalTextureBindingEntry(ExternalTextureBindingEntry::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::ExternalTextureBindingEntry },
+    externalTexture(std::move(init.externalTexture)) {}
 
 ExternalTextureBindingEntry::operator const WGPUExternalTextureBindingEntry&() const noexcept {
     return *reinterpret_cast<const WGPUExternalTextureBindingEntry*>(this);
@@ -5137,12 +5335,12 @@ static_assert(offsetof(ExternalTextureBindingEntry, externalTexture) == offsetof
 
 // ExternalTextureBindingLayout implementation
 ExternalTextureBindingLayout::ExternalTextureBindingLayout()
-  : ChainedStruct { nullptr, SType::ExternalTextureBindingLayout } {}
+: ChainedStruct { nullptr, SType::ExternalTextureBindingLayout } {}
 struct ExternalTextureBindingLayout::Init {
     ChainedStruct * const nextInChain;
 };
-ExternalTextureBindingLayout::ExternalTextureBindingLayout(ExternalTextureBindingLayout::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::ExternalTextureBindingLayout }{}
+ExternalTextureBindingLayout::ExternalTextureBindingLayout(ExternalTextureBindingLayout::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::ExternalTextureBindingLayout } {}
 
 ExternalTextureBindingLayout::operator const WGPUExternalTextureBindingLayout&() const noexcept {
     return *reinterpret_cast<const WGPUExternalTextureBindingLayout*>(this);
@@ -5263,14 +5461,14 @@ static_assert(offsetof(PassTimestampWrites, endOfPassWriteIndex) == offsetof(WGP
 
 // PipelineLayoutResourceTable implementation
 PipelineLayoutResourceTable::PipelineLayoutResourceTable()
-  : ChainedStruct { nullptr, SType::PipelineLayoutResourceTable } {}
+: ChainedStruct { nullptr, SType::PipelineLayoutResourceTable } {}
 struct PipelineLayoutResourceTable::Init {
     ChainedStruct * const nextInChain;
     Bool usesResourceTable = false;
 };
-PipelineLayoutResourceTable::PipelineLayoutResourceTable(PipelineLayoutResourceTable::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::PipelineLayoutResourceTable }, 
-    usesResourceTable(std::move(init.usesResourceTable)){}
+PipelineLayoutResourceTable::PipelineLayoutResourceTable(PipelineLayoutResourceTable::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::PipelineLayoutResourceTable },
+    usesResourceTable(std::move(init.usesResourceTable)) {}
 
 PipelineLayoutResourceTable::operator const WGPUPipelineLayoutResourceTable&() const noexcept {
     return *reinterpret_cast<const WGPUPipelineLayoutResourceTable*>(this);
@@ -5416,7 +5614,7 @@ static_assert(offsetof(RenderPassDepthStencilAttachment, stencilReadOnly) == off
 
 // RenderPassDescriptorResolveRect implementation
 RenderPassDescriptorResolveRect::RenderPassDescriptorResolveRect()
-  : ChainedStruct { nullptr, SType::RenderPassDescriptorResolveRect } {}
+: ChainedStruct { nullptr, SType::RenderPassDescriptorResolveRect } {}
 struct RenderPassDescriptorResolveRect::Init {
     ChainedStruct * const nextInChain;
     uint32_t colorOffsetX;
@@ -5426,14 +5624,14 @@ struct RenderPassDescriptorResolveRect::Init {
     uint32_t width;
     uint32_t height;
 };
-RenderPassDescriptorResolveRect::RenderPassDescriptorResolveRect(RenderPassDescriptorResolveRect::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RenderPassDescriptorResolveRect }, 
-    colorOffsetX(std::move(init.colorOffsetX)), 
-    colorOffsetY(std::move(init.colorOffsetY)), 
-    resolveOffsetX(std::move(init.resolveOffsetX)), 
-    resolveOffsetY(std::move(init.resolveOffsetY)), 
-    width(std::move(init.width)), 
-    height(std::move(init.height)){}
+RenderPassDescriptorResolveRect::RenderPassDescriptorResolveRect(RenderPassDescriptorResolveRect::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::RenderPassDescriptorResolveRect },
+    colorOffsetX(std::move(init.colorOffsetX)),
+    colorOffsetY(std::move(init.colorOffsetY)),
+    resolveOffsetX(std::move(init.resolveOffsetX)),
+    resolveOffsetY(std::move(init.resolveOffsetY)),
+    width(std::move(init.width)),
+    height(std::move(init.height)) {}
 
 RenderPassDescriptorResolveRect::operator const WGPURenderPassDescriptorResolveRect&() const noexcept {
     return *reinterpret_cast<const WGPURenderPassDescriptorResolveRect*>(this);
@@ -5456,14 +5654,14 @@ static_assert(offsetof(RenderPassDescriptorResolveRect, height) == offsetof(WGPU
 
 // RenderPassMaxDrawCount implementation
 RenderPassMaxDrawCount::RenderPassMaxDrawCount()
-  : ChainedStruct { nullptr, SType::RenderPassMaxDrawCount } {}
+: ChainedStruct { nullptr, SType::RenderPassMaxDrawCount } {}
 struct RenderPassMaxDrawCount::Init {
     ChainedStruct * const nextInChain;
     uint64_t maxDrawCount = 50000000;
 };
-RenderPassMaxDrawCount::RenderPassMaxDrawCount(RenderPassMaxDrawCount::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RenderPassMaxDrawCount }, 
-    maxDrawCount(std::move(init.maxDrawCount)){}
+RenderPassMaxDrawCount::RenderPassMaxDrawCount(RenderPassMaxDrawCount::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::RenderPassMaxDrawCount },
+    maxDrawCount(std::move(init.maxDrawCount)) {}
 
 RenderPassMaxDrawCount::operator const WGPURenderPassMaxDrawCount&() const noexcept {
     return *reinterpret_cast<const WGPURenderPassMaxDrawCount*>(this);
@@ -5476,12 +5674,12 @@ static_assert(offsetof(RenderPassMaxDrawCount, maxDrawCount) == offsetof(WGPURen
 
 // RequestAdapterWebGPUBackendOptions implementation
 RequestAdapterWebGPUBackendOptions::RequestAdapterWebGPUBackendOptions()
-  : ChainedStruct { nullptr, SType::RequestAdapterWebGPUBackendOptions } {}
+: ChainedStruct { nullptr, SType::RequestAdapterWebGPUBackendOptions } {}
 struct RequestAdapterWebGPUBackendOptions::Init {
     ChainedStruct * const nextInChain;
 };
-RequestAdapterWebGPUBackendOptions::RequestAdapterWebGPUBackendOptions(RequestAdapterWebGPUBackendOptions::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RequestAdapterWebGPUBackendOptions }{}
+RequestAdapterWebGPUBackendOptions::RequestAdapterWebGPUBackendOptions(RequestAdapterWebGPUBackendOptions::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::RequestAdapterWebGPUBackendOptions } {}
 
 RequestAdapterWebGPUBackendOptions::operator const WGPURequestAdapterWebGPUBackendOptions&() const noexcept {
     return *reinterpret_cast<const WGPURequestAdapterWebGPUBackendOptions*>(this);
@@ -5492,14 +5690,14 @@ static_assert(alignof(RequestAdapterWebGPUBackendOptions) == alignof(WGPURequest
 
 // RequestAdapterWebXROptions implementation
 RequestAdapterWebXROptions::RequestAdapterWebXROptions()
-  : ChainedStruct { nullptr, SType::RequestAdapterWebXROptions } {}
+: ChainedStruct { nullptr, SType::RequestAdapterWebXROptions } {}
 struct RequestAdapterWebXROptions::Init {
     ChainedStruct * const nextInChain;
     Bool xrCompatible;
 };
-RequestAdapterWebXROptions::RequestAdapterWebXROptions(RequestAdapterWebXROptions::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RequestAdapterWebXROptions }, 
-    xrCompatible(std::move(init.xrCompatible)){}
+RequestAdapterWebXROptions::RequestAdapterWebXROptions(RequestAdapterWebXROptions::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::RequestAdapterWebXROptions },
+    xrCompatible(std::move(init.xrCompatible)) {}
 
 RequestAdapterWebXROptions::operator const WGPURequestAdapterWebXROptions&() const noexcept {
     return *reinterpret_cast<const WGPURequestAdapterWebXROptions*>(this);
@@ -5540,14 +5738,14 @@ static_assert(offsetof(SamplerBindingLayout, type) == offsetof(WGPUSamplerBindin
 
 // ShaderModuleCompilationOptions implementation
 ShaderModuleCompilationOptions::ShaderModuleCompilationOptions()
-  : ChainedStruct { nullptr, SType::ShaderModuleCompilationOptions } {}
+: ChainedStruct { nullptr, SType::ShaderModuleCompilationOptions } {}
 struct ShaderModuleCompilationOptions::Init {
     ChainedStruct * const nextInChain;
     Bool strictMath;
 };
-ShaderModuleCompilationOptions::ShaderModuleCompilationOptions(ShaderModuleCompilationOptions::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::ShaderModuleCompilationOptions }, 
-    strictMath(std::move(init.strictMath)){}
+ShaderModuleCompilationOptions::ShaderModuleCompilationOptions(ShaderModuleCompilationOptions::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::ShaderModuleCompilationOptions },
+    strictMath(std::move(init.strictMath)) {}
 
 ShaderModuleCompilationOptions::operator const WGPUShaderModuleCompilationOptions&() const noexcept {
     return *reinterpret_cast<const WGPUShaderModuleCompilationOptions*>(this);
@@ -5560,16 +5758,16 @@ static_assert(offsetof(ShaderModuleCompilationOptions, strictMath) == offsetof(W
 
 // ShaderSourceSPIRV implementation
 ShaderSourceSPIRV::ShaderSourceSPIRV()
-  : ChainedStruct { nullptr, SType::ShaderSourceSPIRV } {}
+: ChainedStruct { nullptr, SType::ShaderSourceSPIRV } {}
 struct ShaderSourceSPIRV::Init {
     ChainedStruct * const nextInChain;
     uint32_t codeSize;
     uint32_t const * code = nullptr;
 };
-ShaderSourceSPIRV::ShaderSourceSPIRV(ShaderSourceSPIRV::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::ShaderSourceSPIRV }, 
-    codeSize(std::move(init.codeSize)), 
-    code(std::move(init.code)){}
+ShaderSourceSPIRV::ShaderSourceSPIRV(ShaderSourceSPIRV::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::ShaderSourceSPIRV },
+    codeSize(std::move(init.codeSize)),
+    code(std::move(init.code)) {}
 
 ShaderSourceSPIRV::operator const WGPUShaderSourceSPIRV&() const noexcept {
     return *reinterpret_cast<const WGPUShaderSourceSPIRV*>(this);
@@ -5584,14 +5782,14 @@ static_assert(offsetof(ShaderSourceSPIRV, code) == offsetof(WGPUShaderSourceSPIR
 
 // ShaderSourceWGSL implementation
 ShaderSourceWGSL::ShaderSourceWGSL()
-  : ChainedStruct { nullptr, SType::ShaderSourceWGSL } {}
+: ChainedStruct { nullptr, SType::ShaderSourceWGSL } {}
 struct ShaderSourceWGSL::Init {
     ChainedStruct * const nextInChain;
     StringView code = {};
 };
-ShaderSourceWGSL::ShaderSourceWGSL(ShaderSourceWGSL::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::ShaderSourceWGSL }, 
-    code(std::move(init.code)){}
+ShaderSourceWGSL::ShaderSourceWGSL(ShaderSourceWGSL::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::ShaderSourceWGSL },
+    code(std::move(init.code)) {}
 
 ShaderSourceWGSL::operator const WGPUShaderSourceWGSL&() const noexcept {
     return *reinterpret_cast<const WGPUShaderSourceWGSL*>(this);
@@ -5623,16 +5821,16 @@ static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, signaledValues)
 
 // SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor implementation
 SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor()
-  : ChainedStruct { nullptr, SType::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor } {}
 struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * handle;
     uint64_t size;
 };
-SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor }, 
-    handle(std::move(init.handle)), 
-    size(std::move(init.size)){}
+SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor },
+    handle(std::move(init.handle)),
+    size(std::move(init.size)) {}
 
 SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::operator const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor*>(this);
@@ -5722,14 +5920,14 @@ static_assert(offsetof(SharedBufferMemoryProperties, size) == offsetof(WGPUShare
 
 // SharedFenceDXGISharedHandleDescriptor implementation
 SharedFenceDXGISharedHandleDescriptor::SharedFenceDXGISharedHandleDescriptor()
-  : ChainedStruct { nullptr, SType::SharedFenceDXGISharedHandleDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedFenceDXGISharedHandleDescriptor } {}
 struct SharedFenceDXGISharedHandleDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * handle;
 };
-SharedFenceDXGISharedHandleDescriptor::SharedFenceDXGISharedHandleDescriptor(SharedFenceDXGISharedHandleDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedFenceDXGISharedHandleDescriptor }, 
-    handle(std::move(init.handle)){}
+SharedFenceDXGISharedHandleDescriptor::SharedFenceDXGISharedHandleDescriptor(SharedFenceDXGISharedHandleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedFenceDXGISharedHandleDescriptor },
+    handle(std::move(init.handle)) {}
 
 SharedFenceDXGISharedHandleDescriptor::operator const WGPUSharedFenceDXGISharedHandleDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceDXGISharedHandleDescriptor*>(this);
@@ -5742,14 +5940,14 @@ static_assert(offsetof(SharedFenceDXGISharedHandleDescriptor, handle) == offseto
 
 // SharedFenceDXGISharedHandleExportInfo implementation
 SharedFenceDXGISharedHandleExportInfo::SharedFenceDXGISharedHandleExportInfo()
-  : ChainedStructOut { nullptr, SType::SharedFenceDXGISharedHandleExportInfo } {}
+: ChainedStructOut { nullptr, SType::SharedFenceDXGISharedHandleExportInfo } {}
 struct SharedFenceDXGISharedHandleExportInfo::Init {
     ChainedStructOut *  nextInChain;
     void * handle;
 };
-SharedFenceDXGISharedHandleExportInfo::SharedFenceDXGISharedHandleExportInfo(SharedFenceDXGISharedHandleExportInfo::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedFenceDXGISharedHandleExportInfo }, 
-    handle(std::move(init.handle)){}
+SharedFenceDXGISharedHandleExportInfo::SharedFenceDXGISharedHandleExportInfo(SharedFenceDXGISharedHandleExportInfo::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedFenceDXGISharedHandleExportInfo },
+    handle(std::move(init.handle)) {}
 
 SharedFenceDXGISharedHandleExportInfo::operator const WGPUSharedFenceDXGISharedHandleExportInfo&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceDXGISharedHandleExportInfo*>(this);
@@ -5762,14 +5960,14 @@ static_assert(offsetof(SharedFenceDXGISharedHandleExportInfo, handle) == offseto
 
 // SharedFenceEGLSyncDescriptor implementation
 SharedFenceEGLSyncDescriptor::SharedFenceEGLSyncDescriptor()
-  : ChainedStruct { nullptr, SType::SharedFenceEGLSyncDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedFenceEGLSyncDescriptor } {}
 struct SharedFenceEGLSyncDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * sync;
 };
-SharedFenceEGLSyncDescriptor::SharedFenceEGLSyncDescriptor(SharedFenceEGLSyncDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedFenceEGLSyncDescriptor }, 
-    sync(std::move(init.sync)){}
+SharedFenceEGLSyncDescriptor::SharedFenceEGLSyncDescriptor(SharedFenceEGLSyncDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedFenceEGLSyncDescriptor },
+    sync(std::move(init.sync)) {}
 
 SharedFenceEGLSyncDescriptor::operator const WGPUSharedFenceEGLSyncDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceEGLSyncDescriptor*>(this);
@@ -5782,14 +5980,14 @@ static_assert(offsetof(SharedFenceEGLSyncDescriptor, sync) == offsetof(WGPUShare
 
 // SharedFenceEGLSyncExportInfo implementation
 SharedFenceEGLSyncExportInfo::SharedFenceEGLSyncExportInfo()
-  : ChainedStructOut { nullptr, SType::SharedFenceEGLSyncExportInfo } {}
+: ChainedStructOut { nullptr, SType::SharedFenceEGLSyncExportInfo } {}
 struct SharedFenceEGLSyncExportInfo::Init {
     ChainedStructOut *  nextInChain;
     void * sync;
 };
-SharedFenceEGLSyncExportInfo::SharedFenceEGLSyncExportInfo(SharedFenceEGLSyncExportInfo::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedFenceEGLSyncExportInfo }, 
-    sync(std::move(init.sync)){}
+SharedFenceEGLSyncExportInfo::SharedFenceEGLSyncExportInfo(SharedFenceEGLSyncExportInfo::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedFenceEGLSyncExportInfo },
+    sync(std::move(init.sync)) {}
 
 SharedFenceEGLSyncExportInfo::operator const WGPUSharedFenceEGLSyncExportInfo&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceEGLSyncExportInfo*>(this);
@@ -5802,14 +6000,14 @@ static_assert(offsetof(SharedFenceEGLSyncExportInfo, sync) == offsetof(WGPUShare
 
 // SharedFenceMTLSharedEventDescriptor implementation
 SharedFenceMTLSharedEventDescriptor::SharedFenceMTLSharedEventDescriptor()
-  : ChainedStruct { nullptr, SType::SharedFenceMTLSharedEventDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedFenceMTLSharedEventDescriptor } {}
 struct SharedFenceMTLSharedEventDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * sharedEvent;
 };
-SharedFenceMTLSharedEventDescriptor::SharedFenceMTLSharedEventDescriptor(SharedFenceMTLSharedEventDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedFenceMTLSharedEventDescriptor }, 
-    sharedEvent(std::move(init.sharedEvent)){}
+SharedFenceMTLSharedEventDescriptor::SharedFenceMTLSharedEventDescriptor(SharedFenceMTLSharedEventDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedFenceMTLSharedEventDescriptor },
+    sharedEvent(std::move(init.sharedEvent)) {}
 
 SharedFenceMTLSharedEventDescriptor::operator const WGPUSharedFenceMTLSharedEventDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceMTLSharedEventDescriptor*>(this);
@@ -5822,14 +6020,14 @@ static_assert(offsetof(SharedFenceMTLSharedEventDescriptor, sharedEvent) == offs
 
 // SharedFenceMTLSharedEventExportInfo implementation
 SharedFenceMTLSharedEventExportInfo::SharedFenceMTLSharedEventExportInfo()
-  : ChainedStructOut { nullptr, SType::SharedFenceMTLSharedEventExportInfo } {}
+: ChainedStructOut { nullptr, SType::SharedFenceMTLSharedEventExportInfo } {}
 struct SharedFenceMTLSharedEventExportInfo::Init {
     ChainedStructOut *  nextInChain;
     void * sharedEvent;
 };
-SharedFenceMTLSharedEventExportInfo::SharedFenceMTLSharedEventExportInfo(SharedFenceMTLSharedEventExportInfo::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedFenceMTLSharedEventExportInfo }, 
-    sharedEvent(std::move(init.sharedEvent)){}
+SharedFenceMTLSharedEventExportInfo::SharedFenceMTLSharedEventExportInfo(SharedFenceMTLSharedEventExportInfo::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedFenceMTLSharedEventExportInfo },
+    sharedEvent(std::move(init.sharedEvent)) {}
 
 SharedFenceMTLSharedEventExportInfo::operator const WGPUSharedFenceMTLSharedEventExportInfo&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceMTLSharedEventExportInfo*>(this);
@@ -5842,14 +6040,14 @@ static_assert(offsetof(SharedFenceMTLSharedEventExportInfo, sharedEvent) == offs
 
 // SharedFenceSyncFDDescriptor implementation
 SharedFenceSyncFDDescriptor::SharedFenceSyncFDDescriptor()
-  : ChainedStruct { nullptr, SType::SharedFenceSyncFDDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedFenceSyncFDDescriptor } {}
 struct SharedFenceSyncFDDescriptor::Init {
     ChainedStruct * const nextInChain;
     int handle;
 };
-SharedFenceSyncFDDescriptor::SharedFenceSyncFDDescriptor(SharedFenceSyncFDDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedFenceSyncFDDescriptor }, 
-    handle(std::move(init.handle)){}
+SharedFenceSyncFDDescriptor::SharedFenceSyncFDDescriptor(SharedFenceSyncFDDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedFenceSyncFDDescriptor },
+    handle(std::move(init.handle)) {}
 
 SharedFenceSyncFDDescriptor::operator const WGPUSharedFenceSyncFDDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceSyncFDDescriptor*>(this);
@@ -5862,14 +6060,14 @@ static_assert(offsetof(SharedFenceSyncFDDescriptor, handle) == offsetof(WGPUShar
 
 // SharedFenceSyncFDExportInfo implementation
 SharedFenceSyncFDExportInfo::SharedFenceSyncFDExportInfo()
-  : ChainedStructOut { nullptr, SType::SharedFenceSyncFDExportInfo } {}
+: ChainedStructOut { nullptr, SType::SharedFenceSyncFDExportInfo } {}
 struct SharedFenceSyncFDExportInfo::Init {
     ChainedStructOut *  nextInChain;
     int handle;
 };
-SharedFenceSyncFDExportInfo::SharedFenceSyncFDExportInfo(SharedFenceSyncFDExportInfo::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedFenceSyncFDExportInfo }, 
-    handle(std::move(init.handle)){}
+SharedFenceSyncFDExportInfo::SharedFenceSyncFDExportInfo(SharedFenceSyncFDExportInfo::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedFenceSyncFDExportInfo },
+    handle(std::move(init.handle)) {}
 
 SharedFenceSyncFDExportInfo::operator const WGPUSharedFenceSyncFDExportInfo&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceSyncFDExportInfo*>(this);
@@ -5882,14 +6080,14 @@ static_assert(offsetof(SharedFenceSyncFDExportInfo, handle) == offsetof(WGPUShar
 
 // SharedFenceVkSemaphoreOpaqueFDDescriptor implementation
 SharedFenceVkSemaphoreOpaqueFDDescriptor::SharedFenceVkSemaphoreOpaqueFDDescriptor()
-  : ChainedStruct { nullptr, SType::SharedFenceVkSemaphoreOpaqueFDDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedFenceVkSemaphoreOpaqueFDDescriptor } {}
 struct SharedFenceVkSemaphoreOpaqueFDDescriptor::Init {
     ChainedStruct * const nextInChain;
     int handle;
 };
-SharedFenceVkSemaphoreOpaqueFDDescriptor::SharedFenceVkSemaphoreOpaqueFDDescriptor(SharedFenceVkSemaphoreOpaqueFDDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedFenceVkSemaphoreOpaqueFDDescriptor }, 
-    handle(std::move(init.handle)){}
+SharedFenceVkSemaphoreOpaqueFDDescriptor::SharedFenceVkSemaphoreOpaqueFDDescriptor(SharedFenceVkSemaphoreOpaqueFDDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedFenceVkSemaphoreOpaqueFDDescriptor },
+    handle(std::move(init.handle)) {}
 
 SharedFenceVkSemaphoreOpaqueFDDescriptor::operator const WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor*>(this);
@@ -5902,14 +6100,14 @@ static_assert(offsetof(SharedFenceVkSemaphoreOpaqueFDDescriptor, handle) == offs
 
 // SharedFenceVkSemaphoreOpaqueFDExportInfo implementation
 SharedFenceVkSemaphoreOpaqueFDExportInfo::SharedFenceVkSemaphoreOpaqueFDExportInfo()
-  : ChainedStructOut { nullptr, SType::SharedFenceVkSemaphoreOpaqueFDExportInfo } {}
+: ChainedStructOut { nullptr, SType::SharedFenceVkSemaphoreOpaqueFDExportInfo } {}
 struct SharedFenceVkSemaphoreOpaqueFDExportInfo::Init {
     ChainedStructOut *  nextInChain;
     int handle;
 };
-SharedFenceVkSemaphoreOpaqueFDExportInfo::SharedFenceVkSemaphoreOpaqueFDExportInfo(SharedFenceVkSemaphoreOpaqueFDExportInfo::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedFenceVkSemaphoreOpaqueFDExportInfo }, 
-    handle(std::move(init.handle)){}
+SharedFenceVkSemaphoreOpaqueFDExportInfo::SharedFenceVkSemaphoreOpaqueFDExportInfo(SharedFenceVkSemaphoreOpaqueFDExportInfo::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedFenceVkSemaphoreOpaqueFDExportInfo },
+    handle(std::move(init.handle)) {}
 
 SharedFenceVkSemaphoreOpaqueFDExportInfo::operator const WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo*>(this);
@@ -5922,14 +6120,14 @@ static_assert(offsetof(SharedFenceVkSemaphoreOpaqueFDExportInfo, handle) == offs
 
 // SharedFenceVkSemaphoreZirconHandleDescriptor implementation
 SharedFenceVkSemaphoreZirconHandleDescriptor::SharedFenceVkSemaphoreZirconHandleDescriptor()
-  : ChainedStruct { nullptr, SType::SharedFenceVkSemaphoreZirconHandleDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedFenceVkSemaphoreZirconHandleDescriptor } {}
 struct SharedFenceVkSemaphoreZirconHandleDescriptor::Init {
     ChainedStruct * const nextInChain;
     uint32_t handle;
 };
-SharedFenceVkSemaphoreZirconHandleDescriptor::SharedFenceVkSemaphoreZirconHandleDescriptor(SharedFenceVkSemaphoreZirconHandleDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedFenceVkSemaphoreZirconHandleDescriptor }, 
-    handle(std::move(init.handle)){}
+SharedFenceVkSemaphoreZirconHandleDescriptor::SharedFenceVkSemaphoreZirconHandleDescriptor(SharedFenceVkSemaphoreZirconHandleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedFenceVkSemaphoreZirconHandleDescriptor },
+    handle(std::move(init.handle)) {}
 
 SharedFenceVkSemaphoreZirconHandleDescriptor::operator const WGPUSharedFenceVkSemaphoreZirconHandleDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceVkSemaphoreZirconHandleDescriptor*>(this);
@@ -5942,14 +6140,14 @@ static_assert(offsetof(SharedFenceVkSemaphoreZirconHandleDescriptor, handle) ==
 
 // SharedFenceVkSemaphoreZirconHandleExportInfo implementation
 SharedFenceVkSemaphoreZirconHandleExportInfo::SharedFenceVkSemaphoreZirconHandleExportInfo()
-  : ChainedStructOut { nullptr, SType::SharedFenceVkSemaphoreZirconHandleExportInfo } {}
+: ChainedStructOut { nullptr, SType::SharedFenceVkSemaphoreZirconHandleExportInfo } {}
 struct SharedFenceVkSemaphoreZirconHandleExportInfo::Init {
     ChainedStructOut *  nextInChain;
     uint32_t handle;
 };
-SharedFenceVkSemaphoreZirconHandleExportInfo::SharedFenceVkSemaphoreZirconHandleExportInfo(SharedFenceVkSemaphoreZirconHandleExportInfo::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedFenceVkSemaphoreZirconHandleExportInfo }, 
-    handle(std::move(init.handle)){}
+SharedFenceVkSemaphoreZirconHandleExportInfo::SharedFenceVkSemaphoreZirconHandleExportInfo(SharedFenceVkSemaphoreZirconHandleExportInfo::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedFenceVkSemaphoreZirconHandleExportInfo },
+    handle(std::move(init.handle)) {}
 
 SharedFenceVkSemaphoreZirconHandleExportInfo::operator const WGPUSharedFenceVkSemaphoreZirconHandleExportInfo&() const noexcept {
     return *reinterpret_cast<const WGPUSharedFenceVkSemaphoreZirconHandleExportInfo*>(this);
@@ -5962,14 +6160,14 @@ static_assert(offsetof(SharedFenceVkSemaphoreZirconHandleExportInfo, handle) ==
 
 // SharedTextureMemoryAHardwareBufferDescriptor implementation
 SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBufferDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryAHardwareBufferDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryAHardwareBufferDescriptor } {}
 struct SharedTextureMemoryAHardwareBufferDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * handle;
 };
-SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBufferDescriptor(SharedTextureMemoryAHardwareBufferDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryAHardwareBufferDescriptor }, 
-    handle(std::move(init.handle)){}
+SharedTextureMemoryAHardwareBufferDescriptor::SharedTextureMemoryAHardwareBufferDescriptor(SharedTextureMemoryAHardwareBufferDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryAHardwareBufferDescriptor },
+    handle(std::move(init.handle)) {}
 
 SharedTextureMemoryAHardwareBufferDescriptor::operator const WGPUSharedTextureMemoryAHardwareBufferDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryAHardwareBufferDescriptor*>(this);
@@ -5982,14 +6180,14 @@ static_assert(offsetof(SharedTextureMemoryAHardwareBufferDescriptor, handle) ==
 
 // SharedTextureMemoryD3D11BeginState implementation
 SharedTextureMemoryD3D11BeginState::SharedTextureMemoryD3D11BeginState()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryD3D11BeginState } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryD3D11BeginState } {}
 struct SharedTextureMemoryD3D11BeginState::Init {
     ChainedStruct * const nextInChain;
     Bool requiresEndAccessFence = true;
 };
-SharedTextureMemoryD3D11BeginState::SharedTextureMemoryD3D11BeginState(SharedTextureMemoryD3D11BeginState::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryD3D11BeginState }, 
-    requiresEndAccessFence(std::move(init.requiresEndAccessFence)){}
+SharedTextureMemoryD3D11BeginState::SharedTextureMemoryD3D11BeginState(SharedTextureMemoryD3D11BeginState::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryD3D11BeginState },
+    requiresEndAccessFence(std::move(init.requiresEndAccessFence)) {}
 
 SharedTextureMemoryD3D11BeginState::operator const WGPUSharedTextureMemoryD3D11BeginState&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryD3D11BeginState*>(this);
@@ -6002,14 +6200,14 @@ static_assert(offsetof(SharedTextureMemoryD3D11BeginState, requiresEndAccessFenc
 
 // SharedTextureMemoryD3DSwapchainBeginState implementation
 SharedTextureMemoryD3DSwapchainBeginState::SharedTextureMemoryD3DSwapchainBeginState()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryD3DSwapchainBeginState } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryD3DSwapchainBeginState } {}
 struct SharedTextureMemoryD3DSwapchainBeginState::Init {
     ChainedStruct * const nextInChain;
     Bool isSwapchain = false;
 };
-SharedTextureMemoryD3DSwapchainBeginState::SharedTextureMemoryD3DSwapchainBeginState(SharedTextureMemoryD3DSwapchainBeginState::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryD3DSwapchainBeginState }, 
-    isSwapchain(std::move(init.isSwapchain)){}
+SharedTextureMemoryD3DSwapchainBeginState::SharedTextureMemoryD3DSwapchainBeginState(SharedTextureMemoryD3DSwapchainBeginState::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryD3DSwapchainBeginState },
+    isSwapchain(std::move(init.isSwapchain)) {}
 
 SharedTextureMemoryD3DSwapchainBeginState::operator const WGPUSharedTextureMemoryD3DSwapchainBeginState&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryD3DSwapchainBeginState*>(this);
@@ -6037,16 +6235,16 @@ static_assert(offsetof(SharedTextureMemoryDmaBufPlane, stride) == offsetof(WGPUS
 
 // SharedTextureMemoryDXGISharedHandleDescriptor implementation
 SharedTextureMemoryDXGISharedHandleDescriptor::SharedTextureMemoryDXGISharedHandleDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryDXGISharedHandleDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryDXGISharedHandleDescriptor } {}
 struct SharedTextureMemoryDXGISharedHandleDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * handle;
     Bool useKeyedMutex;
 };
-SharedTextureMemoryDXGISharedHandleDescriptor::SharedTextureMemoryDXGISharedHandleDescriptor(SharedTextureMemoryDXGISharedHandleDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryDXGISharedHandleDescriptor }, 
-    handle(std::move(init.handle)), 
-    useKeyedMutex(std::move(init.useKeyedMutex)){}
+SharedTextureMemoryDXGISharedHandleDescriptor::SharedTextureMemoryDXGISharedHandleDescriptor(SharedTextureMemoryDXGISharedHandleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryDXGISharedHandleDescriptor },
+    handle(std::move(init.handle)),
+    useKeyedMutex(std::move(init.useKeyedMutex)) {}
 
 SharedTextureMemoryDXGISharedHandleDescriptor::operator const WGPUSharedTextureMemoryDXGISharedHandleDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryDXGISharedHandleDescriptor*>(this);
@@ -6061,14 +6259,14 @@ static_assert(offsetof(SharedTextureMemoryDXGISharedHandleDescriptor, useKeyedMu
 
 // SharedTextureMemoryEGLImageDescriptor implementation
 SharedTextureMemoryEGLImageDescriptor::SharedTextureMemoryEGLImageDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryEGLImageDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryEGLImageDescriptor } {}
 struct SharedTextureMemoryEGLImageDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * image;
 };
-SharedTextureMemoryEGLImageDescriptor::SharedTextureMemoryEGLImageDescriptor(SharedTextureMemoryEGLImageDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryEGLImageDescriptor }, 
-    image(std::move(init.image)){}
+SharedTextureMemoryEGLImageDescriptor::SharedTextureMemoryEGLImageDescriptor(SharedTextureMemoryEGLImageDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryEGLImageDescriptor },
+    image(std::move(init.image)) {}
 
 SharedTextureMemoryEGLImageDescriptor::operator const WGPUSharedTextureMemoryEGLImageDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryEGLImageDescriptor*>(this);
@@ -6081,16 +6279,16 @@ static_assert(offsetof(SharedTextureMemoryEGLImageDescriptor, image) == offsetof
 
 // SharedTextureMemoryIOSurfaceDescriptor implementation
 SharedTextureMemoryIOSurfaceDescriptor::SharedTextureMemoryIOSurfaceDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryIOSurfaceDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryIOSurfaceDescriptor } {}
 struct SharedTextureMemoryIOSurfaceDescriptor::Init {
     ChainedStruct * const nextInChain;
     void * ioSurface;
     Bool allowStorageBinding = true;
 };
-SharedTextureMemoryIOSurfaceDescriptor::SharedTextureMemoryIOSurfaceDescriptor(SharedTextureMemoryIOSurfaceDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryIOSurfaceDescriptor }, 
-    ioSurface(std::move(init.ioSurface)), 
-    allowStorageBinding(std::move(init.allowStorageBinding)){}
+SharedTextureMemoryIOSurfaceDescriptor::SharedTextureMemoryIOSurfaceDescriptor(SharedTextureMemoryIOSurfaceDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryIOSurfaceDescriptor },
+    ioSurface(std::move(init.ioSurface)),
+    allowStorageBinding(std::move(init.allowStorageBinding)) {}
 
 SharedTextureMemoryIOSurfaceDescriptor::operator const WGPUSharedTextureMemoryIOSurfaceDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryIOSurfaceDescriptor*>(this);
@@ -6105,7 +6303,7 @@ static_assert(offsetof(SharedTextureMemoryIOSurfaceDescriptor, allowStorageBindi
 
 // SharedTextureMemoryOpaqueFDDescriptor implementation
 SharedTextureMemoryOpaqueFDDescriptor::SharedTextureMemoryOpaqueFDDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryOpaqueFDDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryOpaqueFDDescriptor } {}
 struct SharedTextureMemoryOpaqueFDDescriptor::Init {
     ChainedStruct * const nextInChain;
     void const * vkImageCreateInfo;
@@ -6114,13 +6312,13 @@ struct SharedTextureMemoryOpaqueFDDescriptor::Init {
     uint64_t allocationSize;
     Bool dedicatedAllocation;
 };
-SharedTextureMemoryOpaqueFDDescriptor::SharedTextureMemoryOpaqueFDDescriptor(SharedTextureMemoryOpaqueFDDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryOpaqueFDDescriptor }, 
-    vkImageCreateInfo(std::move(init.vkImageCreateInfo)), 
-    memoryFD(std::move(init.memoryFD)), 
-    memoryTypeIndex(std::move(init.memoryTypeIndex)), 
-    allocationSize(std::move(init.allocationSize)), 
-    dedicatedAllocation(std::move(init.dedicatedAllocation)){}
+SharedTextureMemoryOpaqueFDDescriptor::SharedTextureMemoryOpaqueFDDescriptor(SharedTextureMemoryOpaqueFDDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryOpaqueFDDescriptor },
+    vkImageCreateInfo(std::move(init.vkImageCreateInfo)),
+    memoryFD(std::move(init.memoryFD)),
+    memoryTypeIndex(std::move(init.memoryTypeIndex)),
+    allocationSize(std::move(init.allocationSize)),
+    dedicatedAllocation(std::move(init.dedicatedAllocation)) {}
 
 SharedTextureMemoryOpaqueFDDescriptor::operator const WGPUSharedTextureMemoryOpaqueFDDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryOpaqueFDDescriptor*>(this);
@@ -6141,14 +6339,14 @@ static_assert(offsetof(SharedTextureMemoryOpaqueFDDescriptor, dedicatedAllocatio
 
 // SharedTextureMemoryVkDedicatedAllocationDescriptor implementation
 SharedTextureMemoryVkDedicatedAllocationDescriptor::SharedTextureMemoryVkDedicatedAllocationDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryVkDedicatedAllocationDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryVkDedicatedAllocationDescriptor } {}
 struct SharedTextureMemoryVkDedicatedAllocationDescriptor::Init {
     ChainedStruct * const nextInChain;
     Bool dedicatedAllocation;
 };
-SharedTextureMemoryVkDedicatedAllocationDescriptor::SharedTextureMemoryVkDedicatedAllocationDescriptor(SharedTextureMemoryVkDedicatedAllocationDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryVkDedicatedAllocationDescriptor }, 
-    dedicatedAllocation(std::move(init.dedicatedAllocation)){}
+SharedTextureMemoryVkDedicatedAllocationDescriptor::SharedTextureMemoryVkDedicatedAllocationDescriptor(SharedTextureMemoryVkDedicatedAllocationDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryVkDedicatedAllocationDescriptor },
+    dedicatedAllocation(std::move(init.dedicatedAllocation)) {}
 
 SharedTextureMemoryVkDedicatedAllocationDescriptor::operator const WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor*>(this);
@@ -6161,16 +6359,16 @@ static_assert(offsetof(SharedTextureMemoryVkDedicatedAllocationDescriptor, dedic
 
 // SharedTextureMemoryVkImageLayoutBeginState implementation
 SharedTextureMemoryVkImageLayoutBeginState::SharedTextureMemoryVkImageLayoutBeginState()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryVkImageLayoutBeginState } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryVkImageLayoutBeginState } {}
 struct SharedTextureMemoryVkImageLayoutBeginState::Init {
     ChainedStruct * const nextInChain;
     int32_t oldLayout;
     int32_t newLayout;
 };
-SharedTextureMemoryVkImageLayoutBeginState::SharedTextureMemoryVkImageLayoutBeginState(SharedTextureMemoryVkImageLayoutBeginState::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryVkImageLayoutBeginState }, 
-    oldLayout(std::move(init.oldLayout)), 
-    newLayout(std::move(init.newLayout)){}
+SharedTextureMemoryVkImageLayoutBeginState::SharedTextureMemoryVkImageLayoutBeginState(SharedTextureMemoryVkImageLayoutBeginState::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryVkImageLayoutBeginState },
+    oldLayout(std::move(init.oldLayout)),
+    newLayout(std::move(init.newLayout)) {}
 
 SharedTextureMemoryVkImageLayoutBeginState::operator const WGPUSharedTextureMemoryVkImageLayoutBeginState&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryVkImageLayoutBeginState*>(this);
@@ -6185,16 +6383,16 @@ static_assert(offsetof(SharedTextureMemoryVkImageLayoutBeginState, newLayout) ==
 
 // SharedTextureMemoryVkImageLayoutEndState implementation
 SharedTextureMemoryVkImageLayoutEndState::SharedTextureMemoryVkImageLayoutEndState()
-  : ChainedStructOut { nullptr, SType::SharedTextureMemoryVkImageLayoutEndState } {}
+: ChainedStructOut { nullptr, SType::SharedTextureMemoryVkImageLayoutEndState } {}
 struct SharedTextureMemoryVkImageLayoutEndState::Init {
     ChainedStructOut *  nextInChain;
     int32_t oldLayout;
     int32_t newLayout;
 };
-SharedTextureMemoryVkImageLayoutEndState::SharedTextureMemoryVkImageLayoutEndState(SharedTextureMemoryVkImageLayoutEndState::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedTextureMemoryVkImageLayoutEndState }, 
-    oldLayout(std::move(init.oldLayout)), 
-    newLayout(std::move(init.newLayout)){}
+SharedTextureMemoryVkImageLayoutEndState::SharedTextureMemoryVkImageLayoutEndState(SharedTextureMemoryVkImageLayoutEndState::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedTextureMemoryVkImageLayoutEndState },
+    oldLayout(std::move(init.oldLayout)),
+    newLayout(std::move(init.newLayout)) {}
 
 SharedTextureMemoryVkImageLayoutEndState::operator const WGPUSharedTextureMemoryVkImageLayoutEndState&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryVkImageLayoutEndState*>(this);
@@ -6209,16 +6407,16 @@ static_assert(offsetof(SharedTextureMemoryVkImageLayoutEndState, newLayout) == o
 
 // SharedTextureMemoryZirconHandleDescriptor implementation
 SharedTextureMemoryZirconHandleDescriptor::SharedTextureMemoryZirconHandleDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryZirconHandleDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryZirconHandleDescriptor } {}
 struct SharedTextureMemoryZirconHandleDescriptor::Init {
     ChainedStruct * const nextInChain;
     uint32_t memoryFD;
     uint64_t allocationSize;
 };
-SharedTextureMemoryZirconHandleDescriptor::SharedTextureMemoryZirconHandleDescriptor(SharedTextureMemoryZirconHandleDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryZirconHandleDescriptor }, 
-    memoryFD(std::move(init.memoryFD)), 
-    allocationSize(std::move(init.allocationSize)){}
+SharedTextureMemoryZirconHandleDescriptor::SharedTextureMemoryZirconHandleDescriptor(SharedTextureMemoryZirconHandleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryZirconHandleDescriptor },
+    memoryFD(std::move(init.memoryFD)),
+    allocationSize(std::move(init.allocationSize)) {}
 
 SharedTextureMemoryZirconHandleDescriptor::operator const WGPUSharedTextureMemoryZirconHandleDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryZirconHandleDescriptor*>(this);
@@ -6233,16 +6431,16 @@ static_assert(offsetof(SharedTextureMemoryZirconHandleDescriptor, allocationSize
 
 // StaticSamplerBindingLayout implementation
 StaticSamplerBindingLayout::StaticSamplerBindingLayout()
-  : ChainedStruct { nullptr, SType::StaticSamplerBindingLayout } {}
+: ChainedStruct { nullptr, SType::StaticSamplerBindingLayout } {}
 struct StaticSamplerBindingLayout::Init {
     ChainedStruct * const nextInChain;
     Sampler sampler = nullptr;
     uint32_t sampledTextureBinding = kLimitU32Undefined;
 };
-StaticSamplerBindingLayout::StaticSamplerBindingLayout(StaticSamplerBindingLayout::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::StaticSamplerBindingLayout }, 
-    sampler(std::move(init.sampler)), 
-    sampledTextureBinding(std::move(init.sampledTextureBinding)){}
+StaticSamplerBindingLayout::StaticSamplerBindingLayout(StaticSamplerBindingLayout::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::StaticSamplerBindingLayout },
+    sampler(std::move(init.sampler)),
+    sampledTextureBinding(std::move(init.sampledTextureBinding)) {}
 
 StaticSamplerBindingLayout::operator const WGPUStaticSamplerBindingLayout&() const noexcept {
     return *reinterpret_cast<const WGPUStaticSamplerBindingLayout*>(this);
@@ -6529,16 +6727,16 @@ static_assert(offsetof(SurfaceCapabilities, alphaModes) == offsetof(WGPUSurfaceC
 
 // SurfaceColorManagement implementation
 SurfaceColorManagement::SurfaceColorManagement()
-  : ChainedStruct { nullptr, SType::SurfaceColorManagement } {}
+: ChainedStruct { nullptr, SType::SurfaceColorManagement } {}
 struct SurfaceColorManagement::Init {
     ChainedStruct * const nextInChain;
     PredefinedColorSpace colorSpace = {};
     ToneMappingMode toneMappingMode = {};
 };
-SurfaceColorManagement::SurfaceColorManagement(SurfaceColorManagement::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceColorManagement }, 
-    colorSpace(std::move(init.colorSpace)), 
-    toneMappingMode(std::move(init.toneMappingMode)){}
+SurfaceColorManagement::SurfaceColorManagement(SurfaceColorManagement::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceColorManagement },
+    colorSpace(std::move(init.colorSpace)),
+    toneMappingMode(std::move(init.toneMappingMode)) {}
 
 SurfaceColorManagement::operator const WGPUSurfaceColorManagement&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceColorManagement*>(this);
@@ -6582,14 +6780,14 @@ static_assert(offsetof(SurfaceConfiguration, presentMode) == offsetof(WGPUSurfac
 
 // SurfaceDescriptorFromWindowsCoreWindow implementation
 SurfaceDescriptorFromWindowsCoreWindow::SurfaceDescriptorFromWindowsCoreWindow()
-  : ChainedStruct { nullptr, SType::SurfaceDescriptorFromWindowsCoreWindow } {}
+: ChainedStruct { nullptr, SType::SurfaceDescriptorFromWindowsCoreWindow } {}
 struct SurfaceDescriptorFromWindowsCoreWindow::Init {
     ChainedStruct * const nextInChain;
     void * coreWindow = nullptr;
 };
-SurfaceDescriptorFromWindowsCoreWindow::SurfaceDescriptorFromWindowsCoreWindow(SurfaceDescriptorFromWindowsCoreWindow::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceDescriptorFromWindowsCoreWindow }, 
-    coreWindow(std::move(init.coreWindow)){}
+SurfaceDescriptorFromWindowsCoreWindow::SurfaceDescriptorFromWindowsCoreWindow(SurfaceDescriptorFromWindowsCoreWindow::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceDescriptorFromWindowsCoreWindow },
+    coreWindow(std::move(init.coreWindow)) {}
 
 SurfaceDescriptorFromWindowsCoreWindow::operator const WGPUSurfaceDescriptorFromWindowsCoreWindow&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceDescriptorFromWindowsCoreWindow*>(this);
@@ -6602,14 +6800,14 @@ static_assert(offsetof(SurfaceDescriptorFromWindowsCoreWindow, coreWindow) == of
 
 // SurfaceDescriptorFromWindowsUWPSwapChainPanel implementation
 SurfaceDescriptorFromWindowsUWPSwapChainPanel::SurfaceDescriptorFromWindowsUWPSwapChainPanel()
-  : ChainedStruct { nullptr, SType::SurfaceDescriptorFromWindowsUWPSwapChainPanel } {}
+: ChainedStruct { nullptr, SType::SurfaceDescriptorFromWindowsUWPSwapChainPanel } {}
 struct SurfaceDescriptorFromWindowsUWPSwapChainPanel::Init {
     ChainedStruct * const nextInChain;
     void * swapChainPanel = nullptr;
 };
-SurfaceDescriptorFromWindowsUWPSwapChainPanel::SurfaceDescriptorFromWindowsUWPSwapChainPanel(SurfaceDescriptorFromWindowsUWPSwapChainPanel::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceDescriptorFromWindowsUWPSwapChainPanel }, 
-    swapChainPanel(std::move(init.swapChainPanel)){}
+SurfaceDescriptorFromWindowsUWPSwapChainPanel::SurfaceDescriptorFromWindowsUWPSwapChainPanel(SurfaceDescriptorFromWindowsUWPSwapChainPanel::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceDescriptorFromWindowsUWPSwapChainPanel },
+    swapChainPanel(std::move(init.swapChainPanel)) {}
 
 SurfaceDescriptorFromWindowsUWPSwapChainPanel::operator const WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel*>(this);
@@ -6622,14 +6820,14 @@ static_assert(offsetof(SurfaceDescriptorFromWindowsUWPSwapChainPanel, swapChainP
 
 // SurfaceDescriptorFromWindowsWinUISwapChainPanel implementation
 SurfaceDescriptorFromWindowsWinUISwapChainPanel::SurfaceDescriptorFromWindowsWinUISwapChainPanel()
-  : ChainedStruct { nullptr, SType::SurfaceDescriptorFromWindowsWinUISwapChainPanel } {}
+: ChainedStruct { nullptr, SType::SurfaceDescriptorFromWindowsWinUISwapChainPanel } {}
 struct SurfaceDescriptorFromWindowsWinUISwapChainPanel::Init {
     ChainedStruct * const nextInChain;
     void * swapChainPanel = nullptr;
 };
-SurfaceDescriptorFromWindowsWinUISwapChainPanel::SurfaceDescriptorFromWindowsWinUISwapChainPanel(SurfaceDescriptorFromWindowsWinUISwapChainPanel::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceDescriptorFromWindowsWinUISwapChainPanel }, 
-    swapChainPanel(std::move(init.swapChainPanel)){}
+SurfaceDescriptorFromWindowsWinUISwapChainPanel::SurfaceDescriptorFromWindowsWinUISwapChainPanel(SurfaceDescriptorFromWindowsWinUISwapChainPanel::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceDescriptorFromWindowsWinUISwapChainPanel },
+    swapChainPanel(std::move(init.swapChainPanel)) {}
 
 SurfaceDescriptorFromWindowsWinUISwapChainPanel::operator const WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel*>(this);
@@ -6642,14 +6840,14 @@ static_assert(offsetof(SurfaceDescriptorFromWindowsWinUISwapChainPanel, swapChai
 
 // SurfaceSourceAndroidNativeWindow implementation
 SurfaceSourceAndroidNativeWindow::SurfaceSourceAndroidNativeWindow()
-  : ChainedStruct { nullptr, SType::SurfaceSourceAndroidNativeWindow } {}
+: ChainedStruct { nullptr, SType::SurfaceSourceAndroidNativeWindow } {}
 struct SurfaceSourceAndroidNativeWindow::Init {
     ChainedStruct * const nextInChain;
     void * window;
 };
-SurfaceSourceAndroidNativeWindow::SurfaceSourceAndroidNativeWindow(SurfaceSourceAndroidNativeWindow::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceSourceAndroidNativeWindow }, 
-    window(std::move(init.window)){}
+SurfaceSourceAndroidNativeWindow::SurfaceSourceAndroidNativeWindow(SurfaceSourceAndroidNativeWindow::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceSourceAndroidNativeWindow },
+    window(std::move(init.window)) {}
 
 SurfaceSourceAndroidNativeWindow::operator const WGPUSurfaceSourceAndroidNativeWindow&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceSourceAndroidNativeWindow*>(this);
@@ -6662,14 +6860,14 @@ static_assert(offsetof(SurfaceSourceAndroidNativeWindow, window) == offsetof(WGP
 
 // SurfaceSourceMetalLayer implementation
 SurfaceSourceMetalLayer::SurfaceSourceMetalLayer()
-  : ChainedStruct { nullptr, SType::SurfaceSourceMetalLayer } {}
+: ChainedStruct { nullptr, SType::SurfaceSourceMetalLayer } {}
 struct SurfaceSourceMetalLayer::Init {
     ChainedStruct * const nextInChain;
     void * layer = nullptr;
 };
-SurfaceSourceMetalLayer::SurfaceSourceMetalLayer(SurfaceSourceMetalLayer::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceSourceMetalLayer }, 
-    layer(std::move(init.layer)){}
+SurfaceSourceMetalLayer::SurfaceSourceMetalLayer(SurfaceSourceMetalLayer::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceSourceMetalLayer },
+    layer(std::move(init.layer)) {}
 
 SurfaceSourceMetalLayer::operator const WGPUSurfaceSourceMetalLayer&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceSourceMetalLayer*>(this);
@@ -6682,16 +6880,16 @@ static_assert(offsetof(SurfaceSourceMetalLayer, layer) == offsetof(WGPUSurfaceSo
 
 // SurfaceSourceWaylandSurface implementation
 SurfaceSourceWaylandSurface::SurfaceSourceWaylandSurface()
-  : ChainedStruct { nullptr, SType::SurfaceSourceWaylandSurface } {}
+: ChainedStruct { nullptr, SType::SurfaceSourceWaylandSurface } {}
 struct SurfaceSourceWaylandSurface::Init {
     ChainedStruct * const nextInChain;
     void * display = nullptr;
     void * surface = nullptr;
 };
-SurfaceSourceWaylandSurface::SurfaceSourceWaylandSurface(SurfaceSourceWaylandSurface::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceSourceWaylandSurface }, 
-    display(std::move(init.display)), 
-    surface(std::move(init.surface)){}
+SurfaceSourceWaylandSurface::SurfaceSourceWaylandSurface(SurfaceSourceWaylandSurface::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceSourceWaylandSurface },
+    display(std::move(init.display)),
+    surface(std::move(init.surface)) {}
 
 SurfaceSourceWaylandSurface::operator const WGPUSurfaceSourceWaylandSurface&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceSourceWaylandSurface*>(this);
@@ -6706,16 +6904,16 @@ static_assert(offsetof(SurfaceSourceWaylandSurface, surface) == offsetof(WGPUSur
 
 // SurfaceSourceWindowsHWND implementation
 SurfaceSourceWindowsHWND::SurfaceSourceWindowsHWND()
-  : ChainedStruct { nullptr, SType::SurfaceSourceWindowsHWND } {}
+: ChainedStruct { nullptr, SType::SurfaceSourceWindowsHWND } {}
 struct SurfaceSourceWindowsHWND::Init {
     ChainedStruct * const nextInChain;
     void * hinstance = nullptr;
     void * hwnd = nullptr;
 };
-SurfaceSourceWindowsHWND::SurfaceSourceWindowsHWND(SurfaceSourceWindowsHWND::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceSourceWindowsHWND }, 
-    hinstance(std::move(init.hinstance)), 
-    hwnd(std::move(init.hwnd)){}
+SurfaceSourceWindowsHWND::SurfaceSourceWindowsHWND(SurfaceSourceWindowsHWND::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceSourceWindowsHWND },
+    hinstance(std::move(init.hinstance)),
+    hwnd(std::move(init.hwnd)) {}
 
 SurfaceSourceWindowsHWND::operator const WGPUSurfaceSourceWindowsHWND&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceSourceWindowsHWND*>(this);
@@ -6730,16 +6928,16 @@ static_assert(offsetof(SurfaceSourceWindowsHWND, hwnd) == offsetof(WGPUSurfaceSo
 
 // SurfaceSourceXCBWindow implementation
 SurfaceSourceXCBWindow::SurfaceSourceXCBWindow()
-  : ChainedStruct { nullptr, SType::SurfaceSourceXCBWindow } {}
+: ChainedStruct { nullptr, SType::SurfaceSourceXCBWindow } {}
 struct SurfaceSourceXCBWindow::Init {
     ChainedStruct * const nextInChain;
     void * connection = nullptr;
     uint32_t window;
 };
-SurfaceSourceXCBWindow::SurfaceSourceXCBWindow(SurfaceSourceXCBWindow::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceSourceXCBWindow }, 
-    connection(std::move(init.connection)), 
-    window(std::move(init.window)){}
+SurfaceSourceXCBWindow::SurfaceSourceXCBWindow(SurfaceSourceXCBWindow::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceSourceXCBWindow },
+    connection(std::move(init.connection)),
+    window(std::move(init.window)) {}
 
 SurfaceSourceXCBWindow::operator const WGPUSurfaceSourceXCBWindow&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceSourceXCBWindow*>(this);
@@ -6754,16 +6952,16 @@ static_assert(offsetof(SurfaceSourceXCBWindow, window) == offsetof(WGPUSurfaceSo
 
 // SurfaceSourceXlibWindow implementation
 SurfaceSourceXlibWindow::SurfaceSourceXlibWindow()
-  : ChainedStruct { nullptr, SType::SurfaceSourceXlibWindow } {}
+: ChainedStruct { nullptr, SType::SurfaceSourceXlibWindow } {}
 struct SurfaceSourceXlibWindow::Init {
     ChainedStruct * const nextInChain;
     void * display = nullptr;
     uint64_t window;
 };
-SurfaceSourceXlibWindow::SurfaceSourceXlibWindow(SurfaceSourceXlibWindow::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SurfaceSourceXlibWindow }, 
-    display(std::move(init.display)), 
-    window(std::move(init.window)){}
+SurfaceSourceXlibWindow::SurfaceSourceXlibWindow(SurfaceSourceXlibWindow::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SurfaceSourceXlibWindow },
+    display(std::move(init.display)),
+    window(std::move(init.window)) {}
 
 SurfaceSourceXlibWindow::operator const WGPUSurfaceSourceXlibWindow&() const noexcept {
     return *reinterpret_cast<const WGPUSurfaceSourceXlibWindow*>(this);
@@ -6793,14 +6991,14 @@ static_assert(offsetof(SurfaceTexture, status) == offsetof(WGPUSurfaceTexture, s
 
 // TexelBufferBindingEntry implementation
 TexelBufferBindingEntry::TexelBufferBindingEntry()
-  : ChainedStruct { nullptr, SType::TexelBufferBindingEntry } {}
+: ChainedStruct { nullptr, SType::TexelBufferBindingEntry } {}
 struct TexelBufferBindingEntry::Init {
     ChainedStruct * const nextInChain;
     TexelBufferView texelBufferView = nullptr;
 };
-TexelBufferBindingEntry::TexelBufferBindingEntry(TexelBufferBindingEntry::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::TexelBufferBindingEntry }, 
-    texelBufferView(std::move(init.texelBufferView)){}
+TexelBufferBindingEntry::TexelBufferBindingEntry(TexelBufferBindingEntry::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::TexelBufferBindingEntry },
+    texelBufferView(std::move(init.texelBufferView)) {}
 
 TexelBufferBindingEntry::operator const WGPUTexelBufferBindingEntry&() const noexcept {
     return *reinterpret_cast<const WGPUTexelBufferBindingEntry*>(this);
@@ -6813,16 +7011,16 @@ static_assert(offsetof(TexelBufferBindingEntry, texelBufferView) == offsetof(WGP
 
 // TexelBufferBindingLayout implementation
 TexelBufferBindingLayout::TexelBufferBindingLayout()
-  : ChainedStruct { nullptr, SType::TexelBufferBindingLayout } {}
+: ChainedStruct { nullptr, SType::TexelBufferBindingLayout } {}
 struct TexelBufferBindingLayout::Init {
     ChainedStruct * const nextInChain;
     TexelBufferAccess access = TexelBufferAccess::Undefined;
     TextureFormat format = TextureFormat::Undefined;
 };
-TexelBufferBindingLayout::TexelBufferBindingLayout(TexelBufferBindingLayout::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::TexelBufferBindingLayout }, 
-    access(std::move(init.access)), 
-    format(std::move(init.format)){}
+TexelBufferBindingLayout::TexelBufferBindingLayout(TexelBufferBindingLayout::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::TexelBufferBindingLayout },
+    access(std::move(init.access)),
+    format(std::move(init.format)) {}
 
 TexelBufferBindingLayout::operator const WGPUTexelBufferBindingLayout&() const noexcept {
     return *reinterpret_cast<const WGPUTexelBufferBindingLayout*>(this);
@@ -6888,14 +7086,14 @@ static_assert(offsetof(TextureBindingLayout, multisampled) == offsetof(WGPUTextu
 
 // TextureBindingViewDimension implementation
 TextureBindingViewDimension::TextureBindingViewDimension()
-  : ChainedStruct { nullptr, SType::TextureBindingViewDimension } {}
+: ChainedStruct { nullptr, SType::TextureBindingViewDimension } {}
 struct TextureBindingViewDimension::Init {
     ChainedStruct * const nextInChain;
     TextureViewDimension textureBindingViewDimension = TextureViewDimension::Undefined;
 };
-TextureBindingViewDimension::TextureBindingViewDimension(TextureBindingViewDimension::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::TextureBindingViewDimension }, 
-    textureBindingViewDimension(std::move(init.textureBindingViewDimension)){}
+TextureBindingViewDimension::TextureBindingViewDimension(TextureBindingViewDimension::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::TextureBindingViewDimension },
+    textureBindingViewDimension(std::move(init.textureBindingViewDimension)) {}
 
 TextureBindingViewDimension::operator const WGPUTextureBindingViewDimension&() const noexcept {
     return *reinterpret_cast<const WGPUTextureBindingViewDimension*>(this);
@@ -6942,7 +7140,7 @@ static_assert(offsetof(VertexAttribute, shaderLocation) == offsetof(WGPUVertexAt
 
 // YCbCrVkDescriptor implementation
 YCbCrVkDescriptor::YCbCrVkDescriptor()
-  : ChainedStruct { nullptr, SType::YCbCrVkDescriptor } {}
+: ChainedStruct { nullptr, SType::YCbCrVkDescriptor } {}
 struct YCbCrVkDescriptor::Init {
     ChainedStruct * const nextInChain;
     uint32_t vkFormat = 0;
@@ -6958,20 +7156,20 @@ struct YCbCrVkDescriptor::Init {
     Bool forceExplicitReconstruction = false;
     uint64_t externalFormat = 0;
 };
-YCbCrVkDescriptor::YCbCrVkDescriptor(YCbCrVkDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::YCbCrVkDescriptor }, 
-    vkFormat(std::move(init.vkFormat)), 
-    vkYCbCrModel(std::move(init.vkYCbCrModel)), 
-    vkYCbCrRange(std::move(init.vkYCbCrRange)), 
-    vkComponentSwizzleRed(std::move(init.vkComponentSwizzleRed)), 
-    vkComponentSwizzleGreen(std::move(init.vkComponentSwizzleGreen)), 
-    vkComponentSwizzleBlue(std::move(init.vkComponentSwizzleBlue)), 
-    vkComponentSwizzleAlpha(std::move(init.vkComponentSwizzleAlpha)), 
-    vkXChromaOffset(std::move(init.vkXChromaOffset)), 
-    vkYChromaOffset(std::move(init.vkYChromaOffset)), 
-    vkChromaFilter(std::move(init.vkChromaFilter)), 
-    forceExplicitReconstruction(std::move(init.forceExplicitReconstruction)), 
-    externalFormat(std::move(init.externalFormat)){}
+YCbCrVkDescriptor::YCbCrVkDescriptor(YCbCrVkDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::YCbCrVkDescriptor },
+    vkFormat(std::move(init.vkFormat)),
+    vkYCbCrModel(std::move(init.vkYCbCrModel)),
+    vkYCbCrRange(std::move(init.vkYCbCrRange)),
+    vkComponentSwizzleRed(std::move(init.vkComponentSwizzleRed)),
+    vkComponentSwizzleGreen(std::move(init.vkComponentSwizzleGreen)),
+    vkComponentSwizzleBlue(std::move(init.vkComponentSwizzleBlue)),
+    vkComponentSwizzleAlpha(std::move(init.vkComponentSwizzleAlpha)),
+    vkXChromaOffset(std::move(init.vkXChromaOffset)),
+    vkYChromaOffset(std::move(init.vkYChromaOffset)),
+    vkChromaFilter(std::move(init.vkChromaFilter)),
+    forceExplicitReconstruction(std::move(init.forceExplicitReconstruction)),
+    externalFormat(std::move(init.externalFormat)) {}
 
 YCbCrVkDescriptor::operator const WGPUYCbCrVkDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUYCbCrVkDescriptor*>(this);
@@ -7006,16 +7204,16 @@ static_assert(offsetof(YCbCrVkDescriptor, externalFormat) == offsetof(WGPUYCbCrV
 
 // AdapterPropertiesMemoryHeaps implementation
 AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesMemoryHeaps } {}
+: ChainedStructOut { nullptr, SType::AdapterPropertiesMemoryHeaps } {}
 struct AdapterPropertiesMemoryHeaps::Init {
     ChainedStructOut *  nextInChain;
     size_t const heapCount = {};
     MemoryHeapInfo const * const heapInfo = nullptr;
 };
-AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesMemoryHeaps }, 
-    heapCount(std::move(init.heapCount)), 
-    heapInfo(std::move(init.heapInfo)){}
+AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::AdapterPropertiesMemoryHeaps },
+    heapCount(std::move(init.heapCount)),
+    heapInfo(std::move(init.heapInfo)) {}
 AdapterPropertiesMemoryHeaps::~AdapterPropertiesMemoryHeaps() {
     FreeMembers();
 }
@@ -7064,16 +7262,16 @@ static_assert(offsetof(AdapterPropertiesMemoryHeaps, heapInfo) == offsetof(WGPUA
 
 // AdapterPropertiesSubgroupMatrixConfigs implementation
 AdapterPropertiesSubgroupMatrixConfigs::AdapterPropertiesSubgroupMatrixConfigs()
-  : ChainedStructOut { nullptr, SType::AdapterPropertiesSubgroupMatrixConfigs } {}
+: ChainedStructOut { nullptr, SType::AdapterPropertiesSubgroupMatrixConfigs } {}
 struct AdapterPropertiesSubgroupMatrixConfigs::Init {
     ChainedStructOut *  nextInChain;
     size_t const configCount = {};
     SubgroupMatrixConfig const * const configs = nullptr;
 };
-AdapterPropertiesSubgroupMatrixConfigs::AdapterPropertiesSubgroupMatrixConfigs(AdapterPropertiesSubgroupMatrixConfigs::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::AdapterPropertiesSubgroupMatrixConfigs }, 
-    configCount(std::move(init.configCount)), 
-    configs(std::move(init.configs)){}
+AdapterPropertiesSubgroupMatrixConfigs::AdapterPropertiesSubgroupMatrixConfigs(AdapterPropertiesSubgroupMatrixConfigs::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::AdapterPropertiesSubgroupMatrixConfigs },
+    configCount(std::move(init.configCount)),
+    configs(std::move(init.configs)) {}
 AdapterPropertiesSubgroupMatrixConfigs::~AdapterPropertiesSubgroupMatrixConfigs() {
     FreeMembers();
 }
@@ -7283,16 +7481,16 @@ static_assert(offsetof(ComputeState, constants) == offsetof(WGPUComputeState, co
 
 // DawnDrmFormatCapabilities implementation
 DawnDrmFormatCapabilities::DawnDrmFormatCapabilities()
-  : ChainedStructOut { nullptr, SType::DawnDrmFormatCapabilities } {}
+: ChainedStructOut { nullptr, SType::DawnDrmFormatCapabilities } {}
 struct DawnDrmFormatCapabilities::Init {
     ChainedStructOut *  nextInChain;
     size_t const propertiesCount = {};
     DawnDrmFormatProperties const * const properties = nullptr;
 };
-DawnDrmFormatCapabilities::DawnDrmFormatCapabilities(DawnDrmFormatCapabilities::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::DawnDrmFormatCapabilities }, 
-    propertiesCount(std::move(init.propertiesCount)), 
-    properties(std::move(init.properties)){}
+DawnDrmFormatCapabilities::DawnDrmFormatCapabilities(DawnDrmFormatCapabilities::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::DawnDrmFormatCapabilities },
+    propertiesCount(std::move(init.propertiesCount)),
+    properties(std::move(init.properties)) {}
 DawnDrmFormatCapabilities::~DawnDrmFormatCapabilities() {
     FreeMembers();
 }
@@ -7531,18 +7729,18 @@ static_assert(offsetof(Limits, maxImmediateSize) == offsetof(WGPULimits, maxImme
 
 // PipelineLayoutPixelLocalStorage implementation
 PipelineLayoutPixelLocalStorage::PipelineLayoutPixelLocalStorage()
-  : ChainedStruct { nullptr, SType::PipelineLayoutPixelLocalStorage } {}
+: ChainedStruct { nullptr, SType::PipelineLayoutPixelLocalStorage } {}
 struct PipelineLayoutPixelLocalStorage::Init {
     ChainedStruct * const nextInChain;
     uint64_t totalPixelLocalStorageSize;
     size_t storageAttachmentCount = 0;
     PipelineLayoutStorageAttachment const * storageAttachments = nullptr;
 };
-PipelineLayoutPixelLocalStorage::PipelineLayoutPixelLocalStorage(PipelineLayoutPixelLocalStorage::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::PipelineLayoutPixelLocalStorage }, 
-    totalPixelLocalStorageSize(std::move(init.totalPixelLocalStorageSize)), 
-    storageAttachmentCount(std::move(init.storageAttachmentCount)), 
-    storageAttachments(std::move(init.storageAttachments)){}
+PipelineLayoutPixelLocalStorage::PipelineLayoutPixelLocalStorage(PipelineLayoutPixelLocalStorage::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::PipelineLayoutPixelLocalStorage },
+    totalPixelLocalStorageSize(std::move(init.totalPixelLocalStorageSize)),
+    storageAttachmentCount(std::move(init.storageAttachmentCount)),
+    storageAttachments(std::move(init.storageAttachments)) {}
 
 PipelineLayoutPixelLocalStorage::operator const WGPUPipelineLayoutPixelLocalStorage&() const noexcept {
     return *reinterpret_cast<const WGPUPipelineLayoutPixelLocalStorage*>(this);
@@ -7582,16 +7780,16 @@ static_assert(offsetof(RenderPassColorAttachment, clearValue) == offsetof(WGPURe
 
 // RenderPassRenderAreaRect implementation
 RenderPassRenderAreaRect::RenderPassRenderAreaRect()
-  : ChainedStruct { nullptr, SType::RenderPassRenderAreaRect } {}
+: ChainedStruct { nullptr, SType::RenderPassRenderAreaRect } {}
 struct RenderPassRenderAreaRect::Init {
     ChainedStruct * const nextInChain;
     Origin2D origin = {};
     Extent2D size = {};
 };
-RenderPassRenderAreaRect::RenderPassRenderAreaRect(RenderPassRenderAreaRect::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RenderPassRenderAreaRect }, 
-    origin(std::move(init.origin)), 
-    size(std::move(init.size)){}
+RenderPassRenderAreaRect::RenderPassRenderAreaRect(RenderPassRenderAreaRect::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::RenderPassRenderAreaRect },
+    origin(std::move(init.origin)),
+    size(std::move(init.size)) {}
 
 RenderPassRenderAreaRect::operator const WGPURenderPassRenderAreaRect&() const noexcept {
     return *reinterpret_cast<const WGPURenderPassRenderAreaRect*>(this);
@@ -7733,14 +7931,14 @@ static_assert(offsetof(SharedFenceExportInfo, type) == offsetof(WGPUSharedFenceE
 
 // SharedTextureMemoryAHardwareBufferProperties implementation
 SharedTextureMemoryAHardwareBufferProperties::SharedTextureMemoryAHardwareBufferProperties()
-  : ChainedStructOut { nullptr, SType::SharedTextureMemoryAHardwareBufferProperties } {}
+: ChainedStructOut { nullptr, SType::SharedTextureMemoryAHardwareBufferProperties } {}
 struct SharedTextureMemoryAHardwareBufferProperties::Init {
     ChainedStructOut *  nextInChain;
     YCbCrVkDescriptor yCbCrInfo = {};
 };
-SharedTextureMemoryAHardwareBufferProperties::SharedTextureMemoryAHardwareBufferProperties(SharedTextureMemoryAHardwareBufferProperties::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedTextureMemoryAHardwareBufferProperties }, 
-    yCbCrInfo(std::move(init.yCbCrInfo)){}
+SharedTextureMemoryAHardwareBufferProperties::SharedTextureMemoryAHardwareBufferProperties(SharedTextureMemoryAHardwareBufferProperties::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedTextureMemoryAHardwareBufferProperties },
+    yCbCrInfo(std::move(init.yCbCrInfo)) {}
 
 SharedTextureMemoryAHardwareBufferProperties::operator const WGPUSharedTextureMemoryAHardwareBufferProperties&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryAHardwareBufferProperties*>(this);
@@ -7774,7 +7972,7 @@ static_assert(offsetof(SharedTextureMemoryBeginAccessDescriptor, signaledValues)
 
 // SharedTextureMemoryDmaBufDescriptor implementation
 SharedTextureMemoryDmaBufDescriptor::SharedTextureMemoryDmaBufDescriptor()
-  : ChainedStruct { nullptr, SType::SharedTextureMemoryDmaBufDescriptor } {}
+: ChainedStruct { nullptr, SType::SharedTextureMemoryDmaBufDescriptor } {}
 struct SharedTextureMemoryDmaBufDescriptor::Init {
     ChainedStruct * const nextInChain;
     Extent3D size = {};
@@ -7783,13 +7981,13 @@ struct SharedTextureMemoryDmaBufDescriptor::Init {
     size_t planeCount;
     SharedTextureMemoryDmaBufPlane const * planes = nullptr;
 };
-SharedTextureMemoryDmaBufDescriptor::SharedTextureMemoryDmaBufDescriptor(SharedTextureMemoryDmaBufDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::SharedTextureMemoryDmaBufDescriptor }, 
-    size(std::move(init.size)), 
-    drmFormat(std::move(init.drmFormat)), 
-    drmModifier(std::move(init.drmModifier)), 
-    planeCount(std::move(init.planeCount)), 
-    planes(std::move(init.planes)){}
+SharedTextureMemoryDmaBufDescriptor::SharedTextureMemoryDmaBufDescriptor(SharedTextureMemoryDmaBufDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedTextureMemoryDmaBufDescriptor },
+    size(std::move(init.size)),
+    drmFormat(std::move(init.drmFormat)),
+    drmModifier(std::move(init.drmModifier)),
+    planeCount(std::move(init.planeCount)),
+    planes(std::move(init.planes)) {}
 
 SharedTextureMemoryDmaBufDescriptor::operator const WGPUSharedTextureMemoryDmaBufDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryDmaBufDescriptor*>(this);
@@ -7810,14 +8008,14 @@ static_assert(offsetof(SharedTextureMemoryDmaBufDescriptor, planes) == offsetof(
 
 // SharedTextureMemoryMetalEndAccessState implementation
 SharedTextureMemoryMetalEndAccessState::SharedTextureMemoryMetalEndAccessState()
-  : ChainedStructOut { nullptr, SType::SharedTextureMemoryMetalEndAccessState } {}
+: ChainedStructOut { nullptr, SType::SharedTextureMemoryMetalEndAccessState } {}
 struct SharedTextureMemoryMetalEndAccessState::Init {
     ChainedStructOut *  nextInChain;
     Future commandsScheduledFuture = {};
 };
-SharedTextureMemoryMetalEndAccessState::SharedTextureMemoryMetalEndAccessState(SharedTextureMemoryMetalEndAccessState::Init&& init)
-  : ChainedStructOut { init.nextInChain, SType::SharedTextureMemoryMetalEndAccessState }, 
-    commandsScheduledFuture(std::move(init.commandsScheduledFuture)){}
+SharedTextureMemoryMetalEndAccessState::SharedTextureMemoryMetalEndAccessState(SharedTextureMemoryMetalEndAccessState::Init&& init) :
+    ChainedStructOut { init.nextInChain, SType::SharedTextureMemoryMetalEndAccessState },
+    commandsScheduledFuture(std::move(init.commandsScheduledFuture)) {}
 
 SharedTextureMemoryMetalEndAccessState::operator const WGPUSharedTextureMemoryMetalEndAccessState&() const noexcept {
     return *reinterpret_cast<const WGPUSharedTextureMemoryMetalEndAccessState*>(this);
@@ -7873,14 +8071,14 @@ static_assert(offsetof(TexelCopyTextureInfo, aspect) == offsetof(WGPUTexelCopyTe
 
 // TextureComponentSwizzleDescriptor implementation
 TextureComponentSwizzleDescriptor::TextureComponentSwizzleDescriptor()
-  : ChainedStruct { nullptr, SType::TextureComponentSwizzleDescriptor } {}
+: ChainedStruct { nullptr, SType::TextureComponentSwizzleDescriptor } {}
 struct TextureComponentSwizzleDescriptor::Init {
     ChainedStruct * const nextInChain;
     TextureComponentSwizzle swizzle = {};
 };
-TextureComponentSwizzleDescriptor::TextureComponentSwizzleDescriptor(TextureComponentSwizzleDescriptor::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::TextureComponentSwizzleDescriptor }, 
-    swizzle(std::move(init.swizzle)){}
+TextureComponentSwizzleDescriptor::TextureComponentSwizzleDescriptor(TextureComponentSwizzleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::TextureComponentSwizzleDescriptor },
+    swizzle(std::move(init.swizzle)) {}
 
 TextureComponentSwizzleDescriptor::operator const WGPUTextureComponentSwizzleDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUTextureComponentSwizzleDescriptor*>(this);
@@ -8125,6 +8323,73 @@ static_assert(alignof(DawnFormatCapabilities) == alignof(WGPUDawnFormatCapabilit
 static_assert(offsetof(DawnFormatCapabilities, nextInChain) == offsetof(WGPUDawnFormatCapabilities, nextInChain),
         "offsetof mismatch for DawnFormatCapabilities::nextInChain");
 
+// DeviceDescriptor implementation
+DeviceDescriptor::DeviceDescriptor() = default;
+struct DeviceDescriptor::Init {
+    ChainedStruct * const nextInChain;
+    StringView label = {};
+    size_t requiredFeatureCount = 0;
+    FeatureName const * requiredFeatures = nullptr;
+    Limits const * requiredLimits = nullptr;
+    QueueDescriptor defaultQueue = {};
+};
+DeviceDescriptor::DeviceDescriptor(DeviceDescriptor::Init&& init) :
+    detail::DeviceDescriptor {
+        init.nextInChain,
+        std::move(init.label),
+        std::move(init.requiredFeatureCount),
+        std::move(init.requiredFeatures),
+        std::move(init.requiredLimits),
+        std::move(init.defaultQueue),
+    } {}
+template <typename F, typename T>
+void DeviceDescriptor::SetDeviceLostCallback(CallbackMode callbackMode, F callback, T userdata) {
+    static_assert(offsetof(DeviceDescriptor, deviceLostCallbackInfo) == offsetof(WGPUDeviceDescriptor, deviceLostCallbackInfo),
+                  "offsetof mismatch for DeviceDescriptor::deviceLostCallbackInfo");
+
+    assert(deviceLostCallbackInfo.callback == nullptr);
+    deviceLostCallbackInfo = detail::CallbackInfoHelper<WGPUDeviceLostCallbackInfo, F>::Create(std::move(callback), userdata);
+    deviceLostCallbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
+}
+template <typename F>
+void DeviceDescriptor::SetDeviceLostCallback(CallbackMode callbackMode, F callback) {
+    assert(deviceLostCallbackInfo.callback == nullptr);
+    deviceLostCallbackInfo = detail::CallbackInfoHelper<WGPUDeviceLostCallbackInfo, F>::Create(std::move(callback));
+    deviceLostCallbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
+}
+template <typename F, typename T>
+void DeviceDescriptor::SetUncapturedErrorCallback(F callback, T userdata) {
+    static_assert(offsetof(DeviceDescriptor, uncapturedErrorCallbackInfo) == offsetof(WGPUDeviceDescriptor, uncapturedErrorCallbackInfo),
+                  "offsetof mismatch for DeviceDescriptor::uncapturedErrorCallbackInfo");
+
+    assert(uncapturedErrorCallbackInfo.callback == nullptr);
+    uncapturedErrorCallbackInfo = detail::CallbackInfoHelper<WGPUUncapturedErrorCallbackInfo, F>::Create(std::move(callback), userdata);
+}
+template <typename F>
+void DeviceDescriptor::SetUncapturedErrorCallback(F callback) {
+    assert(uncapturedErrorCallbackInfo.callback == nullptr);
+    uncapturedErrorCallbackInfo = detail::CallbackInfoHelper<WGPUUncapturedErrorCallbackInfo, F>::Create(std::move(callback));
+}
+
+DeviceDescriptor::operator const WGPUDeviceDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUDeviceDescriptor*>(this);
+}
+
+static_assert(sizeof(DeviceDescriptor) == sizeof(WGPUDeviceDescriptor), "sizeof mismatch for DeviceDescriptor");
+static_assert(alignof(DeviceDescriptor) == alignof(WGPUDeviceDescriptor), "alignof mismatch for DeviceDescriptor");
+static_assert(offsetof(DeviceDescriptor, nextInChain) == offsetof(WGPUDeviceDescriptor, nextInChain),
+        "offsetof mismatch for DeviceDescriptor::nextInChain");
+static_assert(offsetof(DeviceDescriptor, label) == offsetof(WGPUDeviceDescriptor, label),
+        "offsetof mismatch for DeviceDescriptor::label");
+static_assert(offsetof(DeviceDescriptor, requiredFeatureCount) == offsetof(WGPUDeviceDescriptor, requiredFeatureCount),
+        "offsetof mismatch for DeviceDescriptor::requiredFeatureCount");
+static_assert(offsetof(DeviceDescriptor, requiredFeatures) == offsetof(WGPUDeviceDescriptor, requiredFeatures),
+        "offsetof mismatch for DeviceDescriptor::requiredFeatures");
+static_assert(offsetof(DeviceDescriptor, requiredLimits) == offsetof(WGPUDeviceDescriptor, requiredLimits),
+        "offsetof mismatch for DeviceDescriptor::requiredLimits");
+static_assert(offsetof(DeviceDescriptor, defaultQueue) == offsetof(WGPUDeviceDescriptor, defaultQueue),
+        "offsetof mismatch for DeviceDescriptor::defaultQueue");
+
 // PipelineLayoutDescriptor implementation
 
 PipelineLayoutDescriptor::operator const WGPUPipelineLayoutDescriptor&() const noexcept {
@@ -8146,18 +8411,18 @@ static_assert(offsetof(PipelineLayoutDescriptor, immediateSize) == offsetof(WGPU
 
 // RenderPassPixelLocalStorage implementation
 RenderPassPixelLocalStorage::RenderPassPixelLocalStorage()
-  : ChainedStruct { nullptr, SType::RenderPassPixelLocalStorage } {}
+: ChainedStruct { nullptr, SType::RenderPassPixelLocalStorage } {}
 struct RenderPassPixelLocalStorage::Init {
     ChainedStruct * const nextInChain;
     uint64_t totalPixelLocalStorageSize;
     size_t storageAttachmentCount = 0;
     RenderPassStorageAttachment const * storageAttachments = nullptr;
 };
-RenderPassPixelLocalStorage::RenderPassPixelLocalStorage(RenderPassPixelLocalStorage::Init&& init)
-  : ChainedStruct { init.nextInChain, SType::RenderPassPixelLocalStorage }, 
-    totalPixelLocalStorageSize(std::move(init.totalPixelLocalStorageSize)), 
-    storageAttachmentCount(std::move(init.storageAttachmentCount)), 
-    storageAttachments(std::move(init.storageAttachments)){}
+RenderPassPixelLocalStorage::RenderPassPixelLocalStorage(RenderPassPixelLocalStorage::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::RenderPassPixelLocalStorage },
+    totalPixelLocalStorageSize(std::move(init.totalPixelLocalStorageSize)),
+    storageAttachmentCount(std::move(init.storageAttachmentCount)),
+    storageAttachments(std::move(init.storageAttachments)) {}
 
 RenderPassPixelLocalStorage::operator const WGPURenderPassPixelLocalStorage&() const noexcept {
     return *reinterpret_cast<const WGPURenderPassPixelLocalStorage*>(this);
@@ -8385,128 +8650,6 @@ static_assert(offsetof(RenderPipelineDescriptor, multisample) == offsetof(WGPURe
 static_assert(offsetof(RenderPipelineDescriptor, fragment) == offsetof(WGPURenderPipelineDescriptor, fragment),
         "offsetof mismatch for RenderPipelineDescriptor::fragment");
 
-// DeviceDescriptor implementation
-
-DeviceDescriptor::operator const WGPUDeviceDescriptor&() const noexcept {
-    return *reinterpret_cast<const WGPUDeviceDescriptor*>(this);
-}
-
-DeviceDescriptor::DeviceDescriptor() : detail::DeviceDescriptor {} {
-    static_assert(offsetof(DeviceDescriptor, nextInChain) == offsetof(WGPUDeviceDescriptor, nextInChain),
-                "offsetof mismatch for DeviceDescriptor::nextInChain");
-    static_assert(offsetof(DeviceDescriptor, label) == offsetof(WGPUDeviceDescriptor, label),
-            "offsetof mismatch for DeviceDescriptor::label");
-    static_assert(offsetof(DeviceDescriptor, requiredFeatureCount) == offsetof(WGPUDeviceDescriptor, requiredFeatureCount),
-            "offsetof mismatch for DeviceDescriptor::requiredFeatureCount");
-    static_assert(offsetof(DeviceDescriptor, requiredFeatures) == offsetof(WGPUDeviceDescriptor, requiredFeatures),
-            "offsetof mismatch for DeviceDescriptor::requiredFeatures");
-    static_assert(offsetof(DeviceDescriptor, requiredLimits) == offsetof(WGPUDeviceDescriptor, requiredLimits),
-            "offsetof mismatch for DeviceDescriptor::requiredLimits");
-    static_assert(offsetof(DeviceDescriptor, defaultQueue) == offsetof(WGPUDeviceDescriptor, defaultQueue),
-            "offsetof mismatch for DeviceDescriptor::defaultQueue");
-    static_assert(offsetof(DeviceDescriptor, deviceLostCallbackInfo) == offsetof(WGPUDeviceDescriptor, deviceLostCallbackInfo),
-            "offsetof mismatch for DeviceDescriptor::deviceLostCallbackInfo");
-    static_assert(offsetof(DeviceDescriptor, uncapturedErrorCallbackInfo) == offsetof(WGPUDeviceDescriptor, uncapturedErrorCallbackInfo),
-            "offsetof mismatch for DeviceDescriptor::uncapturedErrorCallbackInfo");
-}
-
-struct DeviceDescriptor::Init {
-    ChainedStruct const * nextInChain;
-    StringView label = {};
-    size_t requiredFeatureCount = 0;
-    FeatureName const * requiredFeatures = nullptr;
-    Limits const * requiredLimits = nullptr;
-    QueueDescriptor defaultQueue = {};
-};
-
-DeviceDescriptor::DeviceDescriptor(DeviceDescriptor::Init&& init) : detail::DeviceDescriptor {
-    init.nextInChain, 
-    std::move(init.label), 
-    std::move(init.requiredFeatureCount), 
-    std::move(init.requiredFeatures), 
-    std::move(init.requiredLimits), 
-    std::move(init.defaultQueue)} {}
-
-static_assert(sizeof(DeviceDescriptor) == sizeof(WGPUDeviceDescriptor), "sizeof mismatch for DeviceDescriptor");
-static_assert(alignof(DeviceDescriptor) == alignof(WGPUDeviceDescriptor), "alignof mismatch for DeviceDescriptor");
-
-template <typename F, typename T, typename Cb, typename>
-void DeviceDescriptor::SetDeviceLostCallback(CallbackMode callbackMode, F callback, T userdata) {
-    assert(deviceLostCallbackInfo.callback == nullptr);
-
-    deviceLostCallbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    deviceLostCallbackInfo.callback = [](WGPUDevice const * device, WGPUDeviceLostReason reason, WGPUStringView message, void* callback_param, void* userdata_param) {
-        auto cb = reinterpret_cast<Cb*>(callback_param);
-        // We manually acquire and release the device to avoid changing any ref counts.
-        auto apiDevice = Device::Acquire(*device);
-        (*cb)(apiDevice, static_cast<DeviceLostReason>(reason), message, static_cast<T>(userdata_param));
-        apiDevice.MoveToCHandle();
-    };
-    deviceLostCallbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    deviceLostCallbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
-}
-
-template <typename L, typename Cb, typename>
-void DeviceDescriptor::SetDeviceLostCallback(CallbackMode callbackMode, L callback) {
-    assert(deviceLostCallbackInfo.callback == nullptr);
-    using F = DeviceLostCallback<void>;
-
-    deviceLostCallbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        deviceLostCallbackInfo.callback = [](WGPUDevice const * device, WGPUDeviceLostReason reason, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            // We manually acquire and release the device to avoid changing any ref counts.
-            auto apiDevice = Device::Acquire(*device);
-            (*cb)(apiDevice, static_cast<DeviceLostReason>(reason), message);
-            apiDevice.MoveToCHandle();
-        };
-        deviceLostCallbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        deviceLostCallbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        deviceLostCallbackInfo.callback = [](WGPUDevice const * device, WGPUDeviceLostReason reason, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            // We manually acquire and release the device to avoid changing any ref counts.
-            auto apiDevice = Device::Acquire(*device);
-            (*the_lambda)(apiDevice, static_cast<DeviceLostReason>(reason), message);
-            apiDevice.MoveToCHandle();
-        };
-        deviceLostCallbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        deviceLostCallbackInfo.userdata2 = nullptr;
-    }
-}
-
-template <typename F, typename T, typename Cb, typename>
-void DeviceDescriptor::SetUncapturedErrorCallback(F callback, T userdata) {
-    assert(uncapturedErrorCallbackInfo.callback == nullptr);
-
-    uncapturedErrorCallbackInfo.callback = [](WGPUDevice const * device, WGPUErrorType type, WGPUStringView message, void* callback_param, void* userdata_param) {
-        auto cb = reinterpret_cast<Cb*>(callback_param);
-        // We manually acquire and release the device to avoid changing any ref counts.
-        auto apiDevice = Device::Acquire(*device);
-        (*cb)(apiDevice, static_cast<ErrorType>(type), message, static_cast<T>(userdata_param));
-        apiDevice.MoveToCHandle();
-    };
-    uncapturedErrorCallbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    uncapturedErrorCallbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
-}
-
-template <typename L, typename Cb, typename>
-void DeviceDescriptor::SetUncapturedErrorCallback(L callback) {
-    assert(uncapturedErrorCallbackInfo.callback == nullptr);
-    using F = UncapturedErrorCallback<void>;
-    static_assert(std::is_convertible_v<L, F*>, "Uncaptured error callback cannot be a binding lambda");
-
-    uncapturedErrorCallbackInfo.callback = [](WGPUDevice const * device, WGPUErrorType type, WGPUStringView message, void* callback_param, void*) {
-        auto cb = reinterpret_cast<F*>(callback_param);
-        // We manually acquire and release the device to avoid changing any ref counts.
-        auto apiDevice = Device::Acquire(*device);
-        (*cb)(apiDevice, static_cast<ErrorType>(type), message);
-        apiDevice.MoveToCHandle();
-    };
-    uncapturedErrorCallbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    uncapturedErrorCallbackInfo.userdata2 = nullptr;
-}
 
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
@@ -8543,66 +8686,23 @@ Bool Adapter::HasFeature(FeatureName feature) const {
     auto result = wgpuAdapterHasFeature(Get(), static_cast<WGPUFeatureName>(feature));
     return result;
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Adapter::RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const {
-    WGPURequestDeviceCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Adapter::RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPURequestDeviceCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPURequestDeviceStatus status, WGPUDevice device, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<RequestDeviceStatus>(status), Device::Acquire(device), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPURequestDeviceStatus status, WGPUDevice device, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<RequestDeviceStatus>(status), Device::Acquire(device), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuAdapterRequestDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const *>(descriptor), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Adapter::RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode,L callback) const {
-    using F = RequestDeviceCallback<void>;
-
-    WGPURequestDeviceCallbackInfo callbackInfo = {};
+template <typename F>
+Future Adapter::RequestDevice(DeviceDescriptor const * descriptor, CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPURequestDeviceCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPURequestDeviceStatus status, WGPUDevice device, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<RequestDeviceStatus>(status), Device::Acquire(device), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPURequestDeviceStatus status, WGPUDevice device, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<RequestDeviceStatus>(status), Device::Acquire(device), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuAdapterRequestDevice(Get(), reinterpret_cast<WGPUDeviceDescriptor const *>(descriptor), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 
 
@@ -8688,66 +8788,23 @@ BufferUsage Buffer::GetUsage() const {
     auto result = wgpuBufferGetUsage(Get());
     return static_cast<BufferUsage>(result);
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode,F callback, T userdata) const {
-    WGPUBufferMapCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUBufferMapCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUMapAsyncStatus status, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<MapAsyncStatus>(status), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPUMapAsyncStatus status, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<MapAsyncStatus>(status), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuBufferMapAsync(Get(), static_cast<WGPUMapMode>(mode), offset, size, callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode,L callback) const {
-    using F = BufferMapCallback<void>;
-
-    WGPUBufferMapCallbackInfo callbackInfo = {};
+template <typename F>
+Future Buffer::MapAsync(MapMode mode, size_t offset, size_t size, CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUBufferMapCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUMapAsyncStatus status, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<MapAsyncStatus>(status), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUMapAsyncStatus status, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<MapAsyncStatus>(status), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuBufferMapAsync(Get(), static_cast<WGPUMapMode>(mode), offset, size, callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 ConvertibleStatus Buffer::ReadMappedRange(size_t offset, void * data, size_t size) const {
     auto result = wgpuBufferReadMappedRange(Get(), offset, reinterpret_cast<void *>(data), size);
@@ -8912,66 +8969,23 @@ ComputePipeline Device::CreateComputePipeline(ComputePipelineDescriptor const *
     auto result = wgpuDeviceCreateComputePipeline(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const *>(descriptor));
     return ComputePipeline::Acquire(result);
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const {
-    WGPUCreateComputePipelineAsyncCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUCreateComputePipelineAsyncCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<CreatePipelineAsyncStatus>(status), ComputePipeline::Acquire(pipeline), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<CreatePipelineAsyncStatus>(status), ComputePipeline::Acquire(pipeline), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuDeviceCreateComputePipelineAsync(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode,L callback) const {
-    using F = CreateComputePipelineAsyncCallback<void>;
-
-    WGPUCreateComputePipelineAsyncCallbackInfo callbackInfo = {};
+template <typename F>
+Future Device::CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUCreateComputePipelineAsyncCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<CreatePipelineAsyncStatus>(status), ComputePipeline::Acquire(pipeline), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<CreatePipelineAsyncStatus>(status), ComputePipeline::Acquire(pipeline), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuDeviceCreateComputePipelineAsync(Get(), reinterpret_cast<WGPUComputePipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 Buffer Device::CreateErrorBuffer(BufferDescriptor const * descriptor) const {
     auto result = wgpuDeviceCreateErrorBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const *>(descriptor));
@@ -9009,66 +9023,23 @@ RenderPipeline Device::CreateRenderPipeline(RenderPipelineDescriptor const * des
     auto result = wgpuDeviceCreateRenderPipeline(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const *>(descriptor));
     return RenderPipeline::Acquire(result);
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode,F callback, T userdata) const {
-    WGPUCreateRenderPipelineAsyncCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUCreateRenderPipelineAsyncCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<CreatePipelineAsyncStatus>(status), RenderPipeline::Acquire(pipeline), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<CreatePipelineAsyncStatus>(status), RenderPipeline::Acquire(pipeline), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuDeviceCreateRenderPipelineAsync(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode,L callback) const {
-    using F = CreateRenderPipelineAsyncCallback<void>;
-
-    WGPUCreateRenderPipelineAsyncCallbackInfo callbackInfo = {};
+template <typename F>
+Future Device::CreateRenderPipelineAsync(RenderPipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUCreateRenderPipelineAsyncCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<CreatePipelineAsyncStatus>(status), RenderPipeline::Acquire(pipeline), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<CreatePipelineAsyncStatus>(status), RenderPipeline::Acquire(pipeline), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuDeviceCreateRenderPipelineAsync(Get(), reinterpret_cast<WGPURenderPipelineDescriptor const *>(descriptor), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 ResourceTable Device::CreateResourceTable(ResourceTableDescriptor const * descriptor) const {
     auto result = wgpuDeviceCreateResourceTable(Get(), reinterpret_cast<WGPUResourceTableDescriptor const *>(descriptor));
@@ -9142,66 +9113,23 @@ SharedTextureMemory Device::ImportSharedTextureMemory(SharedTextureMemoryDescrip
 void Device::InjectError(ErrorType type, StringView message) const {
     wgpuDeviceInjectError(Get(), static_cast<WGPUErrorType>(type), *reinterpret_cast<WGPUStringView const*>(&message));
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Device::PopErrorScope(CallbackMode callbackMode,F callback, T userdata) const {
-    WGPUPopErrorScopeCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Device::PopErrorScope(CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUPopErrorScopeCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<PopErrorScopeStatus>(status), static_cast<ErrorType>(type), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<PopErrorScopeStatus>(status), static_cast<ErrorType>(type), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuDevicePopErrorScope(Get(), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Device::PopErrorScope(CallbackMode callbackMode,L callback) const {
-    using F = PopErrorScopeCallback<void>;
-
-    WGPUPopErrorScopeCallbackInfo callbackInfo = {};
+template <typename F>
+Future Device::PopErrorScope(CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUPopErrorScopeCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<PopErrorScopeStatus>(status), static_cast<ErrorType>(type), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<PopErrorScopeStatus>(status), static_cast<ErrorType>(type), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuDevicePopErrorScope(Get(), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 void Device::PushErrorScope(ErrorFilter filter) const {
     wgpuDevicePushErrorScope(Get(), static_cast<WGPUErrorFilter>(filter));
@@ -9209,57 +9137,14 @@ void Device::PushErrorScope(ErrorFilter filter) const {
 void Device::SetLabel(StringView label) const {
     wgpuDeviceSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
+template <typename F, typename T>
 void Device::SetLoggingCallback(F callback, T userdata) const {
-    WGPULoggingCallbackInfo callbackInfo = {};
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPULoggingType type, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<LoggingType>(type), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPULoggingType type, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<LoggingType>(type), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
+    auto callbackInfo = detail::CallbackInfoHelper<WGPULoggingCallbackInfo, F>::Create(std::move(callback), userdata);
     return wgpuDeviceSetLoggingCallback(Get(), callbackInfo);
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-void Device::SetLoggingCallback(L callback) const {
-    using F = LoggingCallback<void>;
-
-    WGPULoggingCallbackInfo callbackInfo = {};
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPULoggingType type, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<LoggingType>(type), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPULoggingType type, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<LoggingType>(type), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
+template <typename F>
+void Device::SetLoggingCallback(F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPULoggingCallbackInfo, F>::Create(std::move(callback));
     return wgpuDeviceSetLoggingCallback(Get(), callbackInfo);
 }
 void Device::Tick() const {
@@ -9329,66 +9214,23 @@ Bool Instance::HasWGSLLanguageFeature(WGSLLanguageFeatureName feature) const {
 void Instance::ProcessEvents() const {
     wgpuInstanceProcessEvents(Get());
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode,F callback, T userdata) const {
-    WGPURequestAdapterCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPURequestAdapterCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPURequestAdapterStatus status, WGPUAdapter adapter, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<RequestAdapterStatus>(status), Adapter::Acquire(adapter), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPURequestAdapterStatus status, WGPUAdapter adapter, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<RequestAdapterStatus>(status), Adapter::Acquire(adapter), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuInstanceRequestAdapter(Get(), reinterpret_cast<WGPURequestAdapterOptions const *>(options), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode,L callback) const {
-    using F = RequestAdapterCallback<void>;
-
-    WGPURequestAdapterCallbackInfo callbackInfo = {};
+template <typename F>
+Future Instance::RequestAdapter(RequestAdapterOptions const * options, CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPURequestAdapterCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPURequestAdapterStatus status, WGPUAdapter adapter, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<RequestAdapterStatus>(status), Adapter::Acquire(adapter), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPURequestAdapterStatus status, WGPUAdapter adapter, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<RequestAdapterStatus>(status), Adapter::Acquire(adapter), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuInstanceRequestAdapter(Get(), reinterpret_cast<WGPURequestAdapterOptions const *>(options), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 WaitStatus Instance::WaitAny(size_t futureCount, FutureWaitInfo * futures, uint64_t timeoutNS) const {
     auto result = wgpuInstanceWaitAny(Get(), futureCount, reinterpret_cast<WGPUFutureWaitInfo *>(futures), timeoutNS);
@@ -9472,66 +9314,23 @@ void Queue::CopyExternalTextureForBrowser(ImageCopyExternalTexture const * sourc
 void Queue::CopyTextureForBrowser(TexelCopyTextureInfo const * source, TexelCopyTextureInfo const * destination, Extent3D const * copySize, CopyTextureForBrowserOptions const * options) const {
     wgpuQueueCopyTextureForBrowser(Get(), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(source), reinterpret_cast<WGPUTexelCopyTextureInfo const *>(destination), reinterpret_cast<WGPUExtent3D const *>(copySize), reinterpret_cast<WGPUCopyTextureForBrowserOptions const *>(options));
 }
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode,F callback, T userdata) const {
-    WGPUQueueWorkDoneCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUQueueWorkDoneCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<QueueWorkDoneStatus>(status), StringView {
-    message.data,
-    message.length
-}, static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<QueueWorkDoneStatus>(status), {detail::StringViewAdapter(message)}, static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuQueueOnSubmittedWorkDone(Get(), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode,L callback) const {
-    using F = QueueWorkDoneCallback<void>;
-
-    WGPUQueueWorkDoneCallbackInfo callbackInfo = {};
+template <typename F>
+Future Queue::OnSubmittedWorkDone(CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUQueueWorkDoneCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<QueueWorkDoneStatus>(status), StringView {
-    message.data,
-    message.length
-});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUQueueWorkDoneStatus status, WGPUStringView message, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<QueueWorkDoneStatus>(status), {detail::StringViewAdapter(message)});
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuQueueOnSubmittedWorkDone(Get(), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 void Queue::SetLabel(StringView label) const {
     wgpuQueueSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
@@ -9621,6 +9420,9 @@ ConvertibleStatus ResourceTable::RemoveBinding(uint32_t slot) const {
     auto result = wgpuResourceTableRemoveBinding(Get(), slot);
     return static_cast<Status>(result);
 }
+void ResourceTable::SetLabel(StringView label) const {
+    wgpuResourceTableSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+}
 ConvertibleStatus ResourceTable::Update(uint32_t slot, BindingResource const * resource) const {
     auto result = wgpuResourceTableUpdate(Get(), slot, reinterpret_cast<WGPUBindingResource const *>(resource));
     return static_cast<Status>(result);
@@ -9662,60 +9464,23 @@ static_assert(alignof(Sampler) == alignof(WGPUSampler), "alignof mismatch for Sa
 
 // ShaderModule implementation
 
-template <typename F, typename T,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future ShaderModule::GetCompilationInfo(CallbackMode callbackMode,F callback, T userdata) const {
-    WGPUCompilationInfoCallbackInfo callbackInfo = {};
+template <typename F, typename T>
+Future ShaderModule::GetCompilationInfo(CallbackMode callbackMode, F callback, T userdata) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUCompilationInfoCallbackInfo, F>::Create(std::move(callback), userdata);
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<F, Cb*>) {
-        callbackInfo.callback = [](WGPUCompilationInfoRequestStatus status, WGPUCompilationInfo const * compilationInfo, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<Cb*>(callback_param);
-            (*cb)(static_cast<CompilationInfoRequestStatus>(status), reinterpret_cast<CompilationInfo const*>(compilationInfo), static_cast<T>(userdata_param));
-        };
-    } else {
-        callbackInfo.callback = [](WGPUCompilationInfoRequestStatus status, WGPUCompilationInfo const * compilationInfo, void* callback_param, void* userdata_param) {
-            auto cb = reinterpret_cast<CbChar*>(callback_param);
-            (*cb)(static_cast<CompilationInfoRequestStatus>(status), reinterpret_cast<CompilationInfo const*>(compilationInfo), static_cast<T>(userdata_param));
-        };
-    }
-    callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-    callbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
     auto result = wgpuShaderModuleGetCompilationInfo(Get(), callbackInfo);
     return Future {
         result.id
     };
 }
-template <typename L,
-          typename Cb,
-          typename CbChar,
-          typename>
-Future ShaderModule::GetCompilationInfo(CallbackMode callbackMode,L callback) const {
-    using F = CompilationInfoCallback<void>;
-
-    WGPUCompilationInfoCallbackInfo callbackInfo = {};
+template <typename F>
+Future ShaderModule::GetCompilationInfo(CallbackMode callbackMode, F callback) const {
+    auto callbackInfo = detail::CallbackInfoHelper<WGPUCompilationInfoCallbackInfo, F>::Create(std::move(callback));
     callbackInfo.mode = static_cast<WGPUCallbackMode>(callbackMode);
-    if constexpr (std::is_convertible_v<L, F*>) {
-        callbackInfo.callback = [](WGPUCompilationInfoRequestStatus status, WGPUCompilationInfo const * compilationInfo, void* callback_param, void*) {
-            auto cb = reinterpret_cast<F*>(callback_param);
-            (*cb)(static_cast<CompilationInfoRequestStatus>(status), reinterpret_cast<CompilationInfo const*>(compilationInfo));
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
-        callbackInfo.userdata2 = nullptr;
-    } else {
-        auto* lambda = new L(std::move(callback));
-        callbackInfo.callback = [](WGPUCompilationInfoRequestStatus status, WGPUCompilationInfo const * compilationInfo, void* callback_param, void*) {
-            std::unique_ptr<L> the_lambda(reinterpret_cast<L*>(callback_param));
-            (*the_lambda)(static_cast<CompilationInfoRequestStatus>(status), reinterpret_cast<CompilationInfo const*>(compilationInfo));
-        };
-        callbackInfo.userdata1 = reinterpret_cast<void*>(lambda);
-        callbackInfo.userdata2 = nullptr;
-    }
     auto result = wgpuShaderModuleGetCompilationInfo(Get(), callbackInfo);
     return Future {
-            result.id
-        };
+        result.id
+    };
 }
 void ShaderModule::SetLabel(StringView label) const {
     wgpuShaderModuleSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));