@shopify/react-native-skia 2.11.0-next.2 → 2.12.0-next.1

package/cpp/dawn/include/webgpu/webgpu_cpp.h

@@ -27,7 +27,7 @@
 
 
 #ifdef __EMSCRIPTEN__
-#error "Do not include this header. Emscripten already provides headers needed for WebGPU."
+#error "Do not include this header. Use the headers provided by Emdawnwebgpu instead."
 #endif
 
 #ifndef WEBGPU_CPP_H_
@@ -40,6 +40,7 @@
 #include <memory>
 #include <optional>
 #include <functional>
+#include <span>
 #include <string_view>
 #include <type_traits>
 #include <utility>
@@ -50,18 +51,18 @@
 
 namespace wgpu {
 
-static constexpr uint32_t kArrayLayerCountUndefined = WGPU_ARRAY_LAYER_COUNT_UNDEFINED;
-static constexpr uint32_t kCopyStrideUndefined = WGPU_COPY_STRIDE_UNDEFINED;
-static constexpr float kDepthClearValueUndefined = std::numeric_limits<float>::quiet_NaN();
-static constexpr uint32_t kDepthSliceUndefined = WGPU_DEPTH_SLICE_UNDEFINED;
-static constexpr uint32_t kInvalidBinding = WGPU_INVALID_BINDING;
-static constexpr uint32_t kLimitU32Undefined = WGPU_LIMIT_U32_UNDEFINED;
-static constexpr uint64_t kLimitU64Undefined = WGPU_LIMIT_U64_UNDEFINED;
-static constexpr uint32_t kMipLevelCountUndefined = WGPU_MIP_LEVEL_COUNT_UNDEFINED;
-static constexpr uint32_t kQuerySetIndexUndefined = WGPU_QUERY_SET_INDEX_UNDEFINED;
-static constexpr size_t kStrlen = WGPU_STRLEN;
-static constexpr size_t kWholeMapSize = WGPU_WHOLE_MAP_SIZE;
-static constexpr uint64_t kWholeSize = WGPU_WHOLE_SIZE;
+inline constexpr uint32_t kArrayLayerCountUndefined = WGPU_ARRAY_LAYER_COUNT_UNDEFINED;
+inline constexpr uint32_t kCopyStrideUndefined = WGPU_COPY_STRIDE_UNDEFINED;
+inline constexpr float kDepthClearValueUndefined = std::numeric_limits<float>::quiet_NaN();
+inline constexpr uint32_t kDepthSliceUndefined = WGPU_DEPTH_SLICE_UNDEFINED;
+inline constexpr uint32_t kInvalidBinding = WGPU_INVALID_BINDING;
+inline constexpr uint32_t kLimitU32Undefined = WGPU_LIMIT_U32_UNDEFINED;
+inline constexpr uint64_t kLimitU64Undefined = WGPU_LIMIT_U64_UNDEFINED;
+inline constexpr uint32_t kMipLevelCountUndefined = WGPU_MIP_LEVEL_COUNT_UNDEFINED;
+inline constexpr uint32_t kQuerySetIndexUndefined = WGPU_QUERY_SET_INDEX_UNDEFINED;
+inline constexpr size_t kStrlen = WGPU_STRLEN;
+inline constexpr size_t kWholeMapSize = WGPU_WHOLE_MAP_SIZE;
+inline constexpr uint64_t kWholeSize = WGPU_WHOLE_SIZE;
 
 enum class AdapterType : uint32_t {
     DiscreteGPU = WGPUAdapterType_DiscreteGPU,
@@ -337,6 +338,7 @@ enum class FeatureName : uint32_t {
     TextureFormatsTier2 = WGPUFeatureName_TextureFormatsTier2,
     PrimitiveIndex = WGPUFeatureName_PrimitiveIndex,
     TextureComponentSwizzle = WGPUFeatureName_TextureComponentSwizzle,
+    SubgroupSizeControl = WGPUFeatureName_SubgroupSizeControl,
     DawnInternalUsages = WGPUFeatureName_DawnInternalUsages,
     DawnMultiPlanarFormats = WGPUFeatureName_DawnMultiPlanarFormats,
     DawnNative = WGPUFeatureName_DawnNative,
@@ -392,16 +394,17 @@ enum class FeatureName : uint32_t {
     SharedFenceEGLSync = WGPUFeatureName_SharedFenceEGLSync,
     DawnDeviceAllocatorControl = WGPUFeatureName_DawnDeviceAllocatorControl,
     AdapterPropertiesWGPU = WGPUFeatureName_AdapterPropertiesWGPU,
-    SharedBufferMemoryD3D12SharedMemoryFileMappingHandle = WGPUFeatureName_SharedBufferMemoryD3D12SharedMemoryFileMappingHandle,
+    SharedBufferMemoryFromWindowsHandle = WGPUFeatureName_SharedBufferMemoryFromWindowsHandle,
     SharedTextureMemoryD3D12Resource = WGPUFeatureName_SharedTextureMemoryD3D12Resource,
     ChromiumExperimentalSamplingResourceTable = WGPUFeatureName_ChromiumExperimentalSamplingResourceTable,
-    SubgroupSizeControl = WGPUFeatureName_SubgroupSizeControl,
     AtomicVec2uMinMax = WGPUFeatureName_AtomicVec2uMinMax,
     Unorm16FormatsForExternalTexture = WGPUFeatureName_Unorm16FormatsForExternalTexture,
     OpaqueYCbCrAndroidForExternalTexture = WGPUFeatureName_OpaqueYCbCrAndroidForExternalTexture,
     Unorm16Filterable = WGPUFeatureName_Unorm16Filterable,
     RenderPassRenderArea = WGPUFeatureName_RenderPassRenderArea,
     AdapterPropertiesDrm = WGPUFeatureName_AdapterPropertiesDrm,
+    TextureCompressionUnaligned = WGPUFeatureName_TextureCompressionUnaligned,
+    DawnAllowUndefinedLoadStoreOp = WGPUFeatureName_DawnAllowUndefinedLoadStoreOp,
 };
 static_assert(sizeof(FeatureName) == sizeof(WGPUFeatureName), "sizeof mismatch for FeatureName");
 static_assert(alignof(FeatureName) == alignof(WGPUFeatureName), "alignof mismatch for FeatureName");
@@ -494,6 +497,7 @@ enum class PredefinedColorSpace : uint32_t {
     DisplayP3 = WGPUPredefinedColorSpace_DisplayP3,
     SRGBLinear = WGPUPredefinedColorSpace_SRGBLinear,
     DisplayP3Linear = WGPUPredefinedColorSpace_DisplayP3Linear,
+    Rec2020Linear = WGPUPredefinedColorSpace_Rec2020Linear,
 };
 static_assert(sizeof(PredefinedColorSpace) == sizeof(WGPUPredefinedColorSpace), "sizeof mismatch for PredefinedColorSpace");
 static_assert(alignof(PredefinedColorSpace) == alignof(WGPUPredefinedColorSpace), "alignof mismatch for PredefinedColorSpace");
@@ -703,7 +707,7 @@ enum class SType : uint32_t {
     TexelBufferBindingLayout = WGPUSType_TexelBufferBindingLayout,
     SharedTextureMemoryMetalEndAccessState = WGPUSType_SharedTextureMemoryMetalEndAccessState,
     AdapterPropertiesWGPU = WGPUSType_AdapterPropertiesWGPU,
-    SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor = WGPUSType_SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor,
+    SharedBufferMemoryFromWindowsHandleDescriptor = WGPUSType_SharedBufferMemoryFromWindowsHandleDescriptor,
     SharedTextureMemoryD3D12ResourceDescriptor = WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor,
     RequestAdapterOptionsAngleVirtualizationGroup = WGPUSType_RequestAdapterOptionsAngleVirtualizationGroup,
     PipelineLayoutResourceTable = WGPUSType_PipelineLayoutResourceTable,
@@ -951,6 +955,7 @@ enum class VertexFormat : uint32_t {
     Sint32x4 = WGPUVertexFormat_Sint32x4,
     Unorm10_10_10_2 = WGPUVertexFormat_Unorm10_10_10_2,
     Unorm8x4BGRA = WGPUVertexFormat_Unorm8x4BGRA,
+    Snorm10_10_10_2 = WGPUVertexFormat_Snorm10_10_10_2,
 };
 static_assert(sizeof(VertexFormat) == sizeof(WGPUVertexFormat), "sizeof mismatch for VertexFormat");
 static_assert(alignof(VertexFormat) == alignof(WGPUVertexFormat), "alignof mismatch for VertexFormat");
@@ -982,6 +987,7 @@ enum class WGSLLanguageFeatureName : uint32_t {
     SubgroupUniformity = WGPUWGSLLanguageFeatureName_SubgroupUniformity,
     TextureFormatsTier1 = WGPUWGSLLanguageFeatureName_TextureFormatsTier1,
     LinearIndexing = WGPUWGSLLanguageFeatureName_LinearIndexing,
+    ImmediateAddressSpace = WGPUWGSLLanguageFeatureName_ImmediateAddressSpace,
     ChromiumTestingUnimplemented = WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented,
     ChromiumTestingUnsafeExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental,
     ChromiumTestingExperimental = WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental,
@@ -991,7 +997,6 @@ enum class WGSLLanguageFeatureName : uint32_t {
     TexelBuffers = WGPUWGSLLanguageFeatureName_TexelBuffers,
     ChromiumPrint = WGPUWGSLLanguageFeatureName_ChromiumPrint,
     FragmentDepth = WGPUWGSLLanguageFeatureName_FragmentDepth,
-    ImmediateAddressSpace = WGPUWGSLLanguageFeatureName_ImmediateAddressSpace,
     BufferView = WGPUWGSLLanguageFeatureName_BufferView,
     SwizzleAssignment = WGPUWGSLLanguageFeatureName_SwizzleAssignment,
 };
@@ -1082,11 +1087,10 @@ using Proc = WGPUProc;
 class Bool {
   public:
     constexpr Bool() = default;
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr Bool(bool value) : mValue(static_cast<WGPUBool>(value)) {}
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    Bool(WGPUBool value): mValue(value) {}
+    explicit(false) constexpr Bool(bool value) : mValue(static_cast<WGPUBool>(value)) {}
+    explicit(false) Bool(WGPUBool value): mValue(value) {}
 
+    // NOLINTNEXTLINE(google-explicit-constructor)
     constexpr operator bool() const { return static_cast<bool>(mValue); }
 
   private:
@@ -1099,13 +1103,10 @@ class Bool {
 class OptionalBool {
   public:
     constexpr OptionalBool() = default;
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr OptionalBool(bool value) : mValue(static_cast<WGPUOptionalBool>(value)) {}
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr OptionalBool(std::optional<bool> value) :
+    explicit(false) constexpr OptionalBool(bool value) : mValue(static_cast<WGPUOptionalBool>(value)) {}
+    explicit(false) constexpr OptionalBool(std::optional<bool> value) :
         mValue(value ? static_cast<WGPUOptionalBool>(*value) : WGPUOptionalBool_Undefined) {}
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr OptionalBool(WGPUOptionalBool value): mValue(value) {}
+    explicit(false) constexpr OptionalBool(WGPUOptionalBool value): mValue(value) {}
 
     // Define the values that are equivalent to the enums.
     static const OptionalBool False;
@@ -1127,7 +1128,9 @@ class OptionalBool {
     }
 
     // Conversion functions.
+    // NOLINTNEXTLINE(google-explicit-constructor)
     operator WGPUOptionalBool() const { return mValue; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
     operator std::optional<bool>() const {
         if (mValue == WGPUOptionalBool_Undefined) {
             return std::nullopt;
@@ -1156,13 +1159,12 @@ inline const OptionalBool OptionalBool::Undefined = OptionalBool(WGPUOptionalBoo
 // Used while callers switch to checking the Status enum instead of booleans.
 // TODO(crbug.com/42241199): Remove when all callers check the enum.
 struct ConvertibleStatus {
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    constexpr ConvertibleStatus(Status status) : status(status) {}
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit conversion
+    explicit(false) constexpr ConvertibleStatus(Status status) : status(status) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
     constexpr operator bool() const {
         return status == Status::Success;
     }
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit conversion
+    // NOLINTNEXTLINE(google-explicit-constructor)
     constexpr operator Status() const {
         return status;
     }
@@ -1173,7 +1175,7 @@ template<typename Derived, typename CType>
 class ObjectBase {
   public:
     ObjectBase() = default;
-    ObjectBase(CType handle): mHandle(handle) {
+    explicit(false) ObjectBase(CType handle): mHandle(handle) {
         if (mHandle) Derived::WGPUAddRef(mHandle);
     }
     ~ObjectBase() {
@@ -1195,19 +1197,19 @@ class ObjectBase {
 
     ObjectBase(ObjectBase&& other) {
         mHandle = other.mHandle;
-        other.mHandle = 0;
+        other.mHandle = nullptr;
     }
     Derived& operator=(ObjectBase&& other) {
         if (&other != this) {
             if (mHandle) Derived::WGPURelease(mHandle);
             mHandle = other.mHandle;
-            other.mHandle = 0;
+            other.mHandle = nullptr;
         }
 
         return static_cast<Derived&>(*this);
     }
 
-    ObjectBase(std::nullptr_t) {}
+    explicit(false) ObjectBase(std::nullptr_t) {}
     Derived& operator=(std::nullptr_t) {
         if (mHandle != nullptr) {
             Derived::WGPURelease(mHandle);
@@ -1231,7 +1233,7 @@ class ObjectBase {
     }
     CType MoveToCHandle() {
         CType result = mHandle;
-        mHandle = 0;
+        mHandle = nullptr;
         return result;
     }
     static Derived Acquire(CType handle) {
@@ -1339,8 +1341,8 @@ struct ShaderModuleCompilationOptions;
 struct ShaderSourceSPIRV;
 struct ShaderSourceWGSL;
 struct SharedBufferMemoryBeginAccessDescriptor;
-struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor;
 struct SharedBufferMemoryEndAccessState;
+struct SharedBufferMemoryFromWindowsHandleDescriptor;
 struct SharedBufferMemoryProperties;
 struct SharedFenceDXGISharedHandleDescriptor;
 struct SharedFenceDXGISharedHandleExportInfo;
@@ -1452,33 +1454,23 @@ struct FragmentState;
 struct RenderPassDescriptor;
 struct RenderPipelineDescriptor;
 
-// TODO(42241188): Remove once all clients use StringView versions of the callbacks.
-// To make MSVC happy we need a StringView constructor from the adapter, so we first need to
-// forward declare StringViewAdapter here. Otherwise MSVC complains about an ambiguous conversion.
-namespace detail {
-    struct StringViewAdapter;
-}  // namespace detail
-
 struct StringView {
     char const * data = nullptr;
     size_t length = WGPU_STRLEN;
 
     inline constexpr StringView() noexcept = default;
 
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    inline constexpr StringView(const std::string_view& sv) noexcept {
+    explicit(false) inline constexpr StringView(const std::string_view& sv) noexcept {
         this->data = sv.data();
         this->length = sv.length();
     }
 
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    inline constexpr StringView(const char* s) {
+    explicit(false) inline constexpr StringView(const char* s) {
         this->data = s;
         this->length = WGPU_STRLEN;  // use strlen
     }
 
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    inline constexpr StringView(WGPUStringView s) {
+    explicit(false) inline constexpr StringView(WGPUStringView s) {
         this->data = s.data;
         this->length = s.length;
     }
@@ -1488,14 +1480,12 @@ struct StringView {
         this->length = length;
     }
 
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    inline constexpr StringView(std::nullptr_t) {
+    explicit(false) inline constexpr StringView(std::nullptr_t) {
         this->data = nullptr;
         this->length = WGPU_STRLEN;
     }
 
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit construction
-    inline constexpr StringView(std::nullopt_t) {
+    explicit(false) inline constexpr StringView(std::nullopt_t) {
         this->data = nullptr;
         this->length = WGPU_STRLEN;
     }
@@ -1504,7 +1494,7 @@ struct StringView {
         return this->data == nullptr && this->length == wgpu::kStrlen;
     }
 
-    // NOLINTNEXTLINE(runtime/explicit) allow implicit conversion
+    // NOLINTNEXTLINE(google-explicit-constructor)
     operator std::string_view() const {
         if (this->length == wgpu::kStrlen) {
             if (IsUndefined()) {
@@ -1527,8 +1517,6 @@ struct StringView {
         return {this->data, this->length};
     }
 
-
-    StringView(const detail::StringViewAdapter& s);
 };
 
 namespace detail {
@@ -1537,77 +1525,92 @@ constexpr size_t ConstexprMax(size_t a, size_t b) {
 }
 
 template <typename T>
-static T& AsNonConstReference(const T& value) {
+inline T& AsNonConstReference(const T& value) {
     return const_cast<T&>(value);
 }
-
-// A wrapper around StringView that can be implicitly converted to const char* with temporary
-// storage that adds the \0 for output strings that are all explicitly-sized.
-// TODO(42241188): Remove once all clients use StringView versions of the callbacks.
-struct StringViewAdapter {
-    WGPUStringView sv;
-    char* nullTerminated = nullptr;
-
-    StringViewAdapter(WGPUStringView sv) : sv(sv) {}
-    ~StringViewAdapter() { delete[] nullTerminated; }
-    operator ::WGPUStringView() { return sv; }
-    operator StringView() { return {sv.data, sv.length}; }
-    operator const char*() {
-        assert(sv.length != WGPU_STRLEN);
-        assert(nullTerminated == nullptr);
-        nullTerminated = new char[sv.length + 1];
-        for (size_t i = 0; i < sv.length; i++) {
-            nullTerminated[i] = sv.data[i];
-        }
-        nullTerminated[sv.length] = 0;
-        return nullTerminated;
-    }
-};
 }  // namespace detail
 
-inline StringView::StringView(const detail::StringViewAdapter& s): data(s.sv.data), length(s.sv.length) {}
-
 namespace detail {
 // For callbacks, we support two modes:
 //   1) No userdata where we allow a std::function type that can include argument captures.
 //   2) Explicit typed userdata where we only allow non-capturing lambdas or function pointers.
-template <typename... Args>
+template <typename R, typename... Args>
 struct CallbackTypeBase;
-template <typename... Args>
-struct CallbackTypeBase<std::tuple<Args...>> {
-    using Callback = std::function<void(Args...)>;
+template <typename R, typename... Args>
+struct CallbackTypeBase<R, std::tuple<Args...>> {
+    using Callback = std::function<R(Args...)>;
+};
+template <typename R, typename... Args>
+struct CallbackTypeBase<R, std::tuple<Args...>, void> {
+    using Callback = R (Args...);
 };
-template <typename... Args>
-struct CallbackTypeBase<std::tuple<Args...>, void> {
-    using Callback = void (Args...);
+template <typename R, typename... Args, typename T>
+struct CallbackTypeBase<R, std::tuple<Args...>, T> {
+    using Callback = R (Args..., T);
 };
-template <typename... Args, typename T>
-struct CallbackTypeBase<std::tuple<Args...>, T> {
-    using Callback = void (Args..., T);
+
+// Noexcept specializations of CallbackTypeBase.
+template <typename R, typename... Args>
+struct CallbackTypeBase<R, std::tuple<Args...>, std::true_type> {
+    using Callback = R (Args...) noexcept;
+};
+template <typename R, typename... Args>
+struct CallbackTypeBase<R, std::tuple<Args...>, void, std::true_type> {
+    using Callback = R (Args...) noexcept;
+};
+template <typename R, typename... Args, typename T>
+struct CallbackTypeBase<R, std::tuple<Args...>, T, std::true_type> {
+    using Callback = R (Args..., T) noexcept;
 };
 }  // namespace detail
 template <typename... T>
-using BufferMapCallback = typename detail::CallbackTypeBase<std::tuple<MapAsyncStatus, StringView>, T...>::Callback;
+using BufferMapCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<MapAsyncStatus, StringView>, T...>::Callback;
+template <typename... T>
+using CompilationInfoCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<CompilationInfoRequestStatus, CompilationInfo const *>, T...>::Callback;
 template <typename... T>
-using CompilationInfoCallback = typename detail::CallbackTypeBase<std::tuple<CompilationInfoRequestStatus, CompilationInfo const *>, T...>::Callback;
+using CreateComputePipelineAsyncCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<CreatePipelineAsyncStatus, ComputePipeline, StringView>, T...>::Callback;
 template <typename... T>
-using CreateComputePipelineAsyncCallback = typename detail::CallbackTypeBase<std::tuple<CreatePipelineAsyncStatus, ComputePipeline, StringView>, T...>::Callback;
+using CreateRenderPipelineAsyncCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<CreatePipelineAsyncStatus, RenderPipeline, StringView>, T...>::Callback;
 template <typename... T>
-using CreateRenderPipelineAsyncCallback = typename detail::CallbackTypeBase<std::tuple<CreatePipelineAsyncStatus, RenderPipeline, StringView>, T...>::Callback;
+using DawnLoadCacheDataCallback = detail::CallbackTypeBase<
+    size_t,
+    std::tuple<size_t, uint8_t const *, size_t, uint8_t *>, T...>::Callback;
 template <typename... T>
-using LoggingCallback = typename detail::CallbackTypeBase<std::tuple<LoggingType, StringView>, T...>::Callback;
+using DawnStoreCacheDataCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<size_t, uint8_t const *, size_t, uint8_t const *>, T...>::Callback;
 template <typename... T>
-using PopErrorScopeCallback = typename detail::CallbackTypeBase<std::tuple<PopErrorScopeStatus, ErrorType, StringView>, T...>::Callback;
+using LoggingCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<LoggingType, StringView>, T...>::Callback;
 template <typename... T>
-using QueueWorkDoneCallback = typename detail::CallbackTypeBase<std::tuple<QueueWorkDoneStatus, StringView>, T...>::Callback;
+using PopErrorScopeCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<PopErrorScopeStatus, ErrorType, StringView>, T...>::Callback;
 template <typename... T>
-using RequestAdapterCallback = typename detail::CallbackTypeBase<std::tuple<RequestAdapterStatus, Adapter, StringView>, T...>::Callback;
+using QueueWorkDoneCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<QueueWorkDoneStatus, StringView>, T...>::Callback;
 template <typename... T>
-using RequestDeviceCallback = typename detail::CallbackTypeBase<std::tuple<RequestDeviceStatus, Device, StringView>, T...>::Callback;
+using RequestAdapterCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<RequestAdapterStatus, Adapter, StringView>, T...>::Callback;
 template <typename... T>
-using DeviceLostCallback = typename detail::CallbackTypeBase<std::tuple<const Device&, DeviceLostReason, StringView>, T...>::Callback;
+using RequestDeviceCallback = detail::CallbackTypeBase<
+    void,
+    std::tuple<RequestDeviceStatus, Device, StringView>, T...>::Callback;
 template <typename... T>
-using UncapturedErrorCallback = typename detail::CallbackTypeBase<std::tuple<const Device&, ErrorType, StringView>, T...>::Callback;
+using DeviceLostCallback = detail::CallbackTypeBase<void, std::tuple<const Device&, DeviceLostReason, StringView>, T...>::Callback;
+template <typename... T>
+using UncapturedErrorCallback = detail::CallbackTypeBase<void, std::tuple<const Device&, ErrorType, StringView>, T...>::Callback;
 
 class Adapter : public ObjectBase<Adapter, WGPUAdapter> {
   public:
@@ -1762,7 +1765,9 @@ class Device : public ObjectBase<Device, WGPUDevice> {
     template <typename F>
     Future CreateComputePipelineAsync(ComputePipelineDescriptor const * descriptor, CallbackMode callbackMode, F callback) const;
     inline Buffer CreateErrorBuffer(BufferDescriptor const * descriptor) const;
+    inline ComputePipeline CreateErrorComputePipeline(StringView label) const;
     inline ExternalTexture CreateErrorExternalTexture() const;
+    inline RenderPipeline CreateErrorRenderPipeline(StringView label) const;
     inline ShaderModule CreateErrorShaderModule(ShaderModuleDescriptor const * descriptor, StringView errorMessage) const;
     inline Texture CreateErrorTexture(TextureDescriptor const * descriptor) const;
     inline ExternalTexture CreateExternalTexture(ExternalTextureDescriptor const * externalTextureDescriptor) const;
@@ -1942,8 +1947,8 @@ class ResourceTable : public ObjectBase<ResourceTable, WGPUResourceTable> {
 
     inline void Destroy() const;
     inline uint32_t GetSize() const;
-    inline uint32_t InsertBinding(BindingResource const * resource) const;
-    inline ConvertibleStatus RemoveBinding(uint32_t slot) const;
+    inline uint32_t Insert(BindingResource const * resource) const;
+    inline ConvertibleStatus Remove(uint32_t slot) const;
     inline void SetLabel(StringView label) const;
     inline ConvertibleStatus Update(uint32_t slot, BindingResource const * resource) const;
 
@@ -2089,10 +2094,8 @@ class Texture : public ObjectBase<Texture, WGPUTexture> {
     inline TextureViewDimension GetTextureBindingViewDimension() const;
     inline TextureUsage GetUsage() const;
     inline uint32_t GetWidth() const;
-    inline void Pin(TextureUsage usage) const;
     inline void SetLabel(StringView label) const;
     inline void SetOwnershipForMemoryDump(uint64_t ownerGuid = 0) const;
-    inline void Unpin() const;
 
 
   private:
@@ -2218,11 +2221,14 @@ static_assert(offsetof(ChainedStruct, nextInChain) == offsetof(WGPUChainedStruct
 static_assert(offsetof(ChainedStruct, sType) == offsetof(WGPUChainedStruct, sType),
     "offsetof mismatch for ChainedStruct::sType");
 
+// NOLINTBEGIN(bugprone-invalid-enum-default-initialization)
+
 // Can be chained in AdapterInfo
 struct AdapterPropertiesD3D : ChainedStructOut {
     inline AdapterPropertiesD3D();
     struct Init;
-    inline AdapterPropertiesD3D(Init&& init);
+    explicit(false) inline AdapterPropertiesD3D(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterPropertiesD3D&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
@@ -2233,7 +2239,8 @@ struct AdapterPropertiesD3D : ChainedStructOut {
 struct AdapterPropertiesDrm : ChainedStructOut {
     inline AdapterPropertiesDrm();
     struct Init;
-    inline AdapterPropertiesDrm(Init&& init);
+    explicit(false) inline AdapterPropertiesDrm(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterPropertiesDrm&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(Bool));
@@ -2249,7 +2256,8 @@ struct AdapterPropertiesDrm : ChainedStructOut {
 struct AdapterPropertiesVk : ChainedStructOut {
     inline AdapterPropertiesVk();
     struct Init;
-    inline AdapterPropertiesVk(Init&& init);
+    explicit(false) inline AdapterPropertiesVk(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterPropertiesVk&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
@@ -2260,7 +2268,8 @@ struct AdapterPropertiesVk : ChainedStructOut {
 struct AdapterPropertiesWGPU : ChainedStructOut {
     inline AdapterPropertiesWGPU();
     struct Init;
-    inline AdapterPropertiesWGPU(Init&& init);
+    explicit(false) inline AdapterPropertiesWGPU(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterPropertiesWGPU&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(BackendType));
@@ -2268,6 +2277,7 @@ struct AdapterPropertiesWGPU : ChainedStructOut {
 };
 
 struct BindingResource {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBindingResource&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2279,6 +2289,7 @@ struct BindingResource {
 };
 
 struct BlendComponent {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBlendComponent&() const noexcept;
 
     BlendOperation operation = BlendOperation::Undefined;
@@ -2287,6 +2298,7 @@ struct BlendComponent {
 };
 
 struct BufferBindingLayout {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBufferBindingLayout&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2299,7 +2311,8 @@ struct BufferBindingLayout {
 struct BufferHostMappedPointer : ChainedStruct {
     inline BufferHostMappedPointer();
     struct Init;
-    inline BufferHostMappedPointer(Init&& init);
+    explicit(false) inline BufferHostMappedPointer(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBufferHostMappedPointer&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -2309,6 +2322,7 @@ struct BufferHostMappedPointer : ChainedStruct {
 };
 
 struct Color {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUColor&() const noexcept;
 
     double r;
@@ -2318,6 +2332,7 @@ struct Color {
 };
 
 struct ColorSpaceDawn {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUColorSpaceDawn&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2325,13 +2340,15 @@ struct ColorSpaceDawn {
     ColorSpaceTransferDawn transfer = ColorSpaceTransferDawn::Identity;
     ColorSpaceYCbCrRangeDawn yCbCrRange = ColorSpaceYCbCrRangeDawn::Identity;
     ColorSpaceYCbCrMatrixDawn yCbCrMatrix = ColorSpaceYCbCrMatrixDawn::Identity;
+    float hdrReferenceWhiteLuminance = 0;
 };
 
 // Can be chained in ColorTargetState
 struct ColorTargetStateExpandResolveTextureDawn : ChainedStruct {
     inline ColorTargetStateExpandResolveTextureDawn();
     struct Init;
-    inline ColorTargetStateExpandResolveTextureDawn(Init&& init);
+    explicit(false) inline ColorTargetStateExpandResolveTextureDawn(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUColorTargetStateExpandResolveTextureDawn&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2339,6 +2356,7 @@ struct ColorTargetStateExpandResolveTextureDawn : ChainedStruct {
 };
 
 struct CommandBufferDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUCommandBufferDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2349,7 +2367,8 @@ struct CommandBufferDescriptor {
 struct CompatibilityModeLimits : ChainedStructOut {
     inline CompatibilityModeLimits();
     struct Init;
-    inline CompatibilityModeLimits(Init&& init);
+    explicit(false) inline CompatibilityModeLimits(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUCompatibilityModeLimits&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
@@ -2360,6 +2379,7 @@ struct CompatibilityModeLimits : ChainedStructOut {
 };
 
 struct ConstantEntry {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUConstantEntry&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2368,6 +2388,7 @@ struct ConstantEntry {
 };
 
 struct CopyTextureForBrowserOptions {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUCopyTextureForBrowserOptions&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2385,7 +2406,8 @@ struct CopyTextureForBrowserOptions {
 struct DawnAdapterPropertiesPowerPreference : ChainedStructOut {
     inline DawnAdapterPropertiesPowerPreference();
     struct Init;
-    inline DawnAdapterPropertiesPowerPreference(Init&& init);
+    explicit(false) inline DawnAdapterPropertiesPowerPreference(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnAdapterPropertiesPowerPreference&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(PowerPreference));
@@ -2396,32 +2418,49 @@ struct DawnAdapterPropertiesPowerPreference : ChainedStructOut {
 struct DawnBufferDescriptorErrorInfoFromWireClient : ChainedStruct {
     inline DawnBufferDescriptorErrorInfoFromWireClient();
     struct Init;
-    inline DawnBufferDescriptorErrorInfoFromWireClient(Init&& init);
+    explicit(false) inline DawnBufferDescriptorErrorInfoFromWireClient(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnBufferDescriptorErrorInfoFromWireClient&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
     alignas(kFirstMemberAlignment) Bool outOfMemory = false;
 };
 
+namespace detail {
+struct DawnCacheDeviceDescriptor {
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
+    alignas(kFirstMemberAlignment) StringView isolationKey = {};
+    WGPUDawnLoadCacheDataCallbackInfo dawnLoadCacheDataCallbackInfo = WGPU_DAWN_LOAD_CACHE_DATA_CALLBACK_INFO_INIT;
+    WGPUDawnStoreCacheDataCallbackInfo dawnStoreCacheDataCallbackInfo = WGPU_DAWN_STORE_CACHE_DATA_CALLBACK_INFO_INIT;
+};
+}  // namespace detail
 // Can be chained in DeviceDescriptor
-struct DawnCacheDeviceDescriptor : ChainedStruct {
+struct DawnCacheDeviceDescriptor : ChainedStruct, protected detail::DawnCacheDeviceDescriptor {
     inline DawnCacheDeviceDescriptor();
     struct Init;
-    inline DawnCacheDeviceDescriptor(Init&& init);
+    explicit(false) inline DawnCacheDeviceDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnCacheDeviceDescriptor&() const noexcept;
 
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
-    alignas(kFirstMemberAlignment) StringView isolationKey = {};
-    DawnLoadCacheDataFunction loadDataFunction = nullptr;
-    DawnStoreCacheDataFunction storeDataFunction = nullptr;
-    void * functionUserdata = nullptr;
+    using detail::DawnCacheDeviceDescriptor::kFirstMemberAlignment;
+    using detail::DawnCacheDeviceDescriptor::isolationKey;
+
+    template <typename F, typename T>
+    void SetDawnLoadCacheDataCallback(F callback, T userdata);
+    template <typename F>
+    void SetDawnLoadCacheDataCallback(F callback);
+    template <typename F, typename T>
+    void SetDawnStoreCacheDataCallback(F callback, T userdata);
+    template <typename F>
+    void SetDawnStoreCacheDataCallback(F callback);
 };
 
 // Can be chained in CompilationMessage
 struct DawnCompilationMessageUtf16 : ChainedStruct {
     inline DawnCompilationMessageUtf16();
     struct Init;
-    inline DawnCompilationMessageUtf16(Init&& init);
+    explicit(false) inline DawnCompilationMessageUtf16(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnCompilationMessageUtf16&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
@@ -2434,7 +2473,8 @@ struct DawnCompilationMessageUtf16 : ChainedStruct {
 struct DawnConsumeAdapterDescriptor : ChainedStruct {
     inline DawnConsumeAdapterDescriptor();
     struct Init;
-    inline DawnConsumeAdapterDescriptor(Init&& init);
+    explicit(false) inline DawnConsumeAdapterDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnConsumeAdapterDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2445,7 +2485,8 @@ struct DawnConsumeAdapterDescriptor : ChainedStruct {
 struct DawnDeviceAllocatorControl : ChainedStruct {
     inline DawnDeviceAllocatorControl();
     struct Init;
-    inline DawnDeviceAllocatorControl(Init&& init);
+    explicit(false) inline DawnDeviceAllocatorControl(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnDeviceAllocatorControl&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
@@ -2453,6 +2494,7 @@ struct DawnDeviceAllocatorControl : ChainedStruct {
 };
 
 struct DawnDrmFormatProperties {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnDrmFormatProperties&() const noexcept;
 
     uint64_t modifier;
@@ -2463,7 +2505,8 @@ struct DawnDrmFormatProperties {
 struct DawnEncoderInternalUsageDescriptor : ChainedStruct {
     inline DawnEncoderInternalUsageDescriptor();
     struct Init;
-    inline DawnEncoderInternalUsageDescriptor(Init&& init);
+    explicit(false) inline DawnEncoderInternalUsageDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnEncoderInternalUsageDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2474,7 +2517,8 @@ struct DawnEncoderInternalUsageDescriptor : ChainedStruct {
 struct DawnFakeBufferOOMForTesting : ChainedStruct {
     inline DawnFakeBufferOOMForTesting();
     struct Init;
-    inline DawnFakeBufferOOMForTesting(Init&& init);
+    explicit(false) inline DawnFakeBufferOOMForTesting(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnFakeBufferOOMForTesting&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2487,7 +2531,8 @@ struct DawnFakeBufferOOMForTesting : ChainedStruct {
 struct DawnFakeDeviceInitializeErrorForTesting : ChainedStruct {
     inline DawnFakeDeviceInitializeErrorForTesting();
     struct Init;
-    inline DawnFakeDeviceInitializeErrorForTesting(Init&& init);
+    explicit(false) inline DawnFakeDeviceInitializeErrorForTesting(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnFakeDeviceInitializeErrorForTesting&() const noexcept;
 
     };
@@ -2496,7 +2541,8 @@ struct DawnFakeDeviceInitializeErrorForTesting : ChainedStruct {
 struct DawnHostMappedPointerLimits : ChainedStructOut {
     inline DawnHostMappedPointerLimits();
     struct Init;
-    inline DawnHostMappedPointerLimits(Init&& init);
+    explicit(false) inline DawnHostMappedPointerLimits(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnHostMappedPointerLimits&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
@@ -2506,7 +2552,8 @@ struct DawnHostMappedPointerLimits : ChainedStructOut {
 struct DawnInjectedInvalidSType : ChainedStruct {
     inline DawnInjectedInvalidSType();
     struct Init;
-    inline DawnInjectedInvalidSType(Init&& init);
+    explicit(false) inline DawnInjectedInvalidSType(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnInjectedInvalidSType&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(SType));
@@ -2517,7 +2564,8 @@ struct DawnInjectedInvalidSType : ChainedStruct {
 struct DawnRenderPassSampleCount : ChainedStruct {
     inline DawnRenderPassSampleCount();
     struct Init;
-    inline DawnRenderPassSampleCount(Init&& init);
+    explicit(false) inline DawnRenderPassSampleCount(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnRenderPassSampleCount&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
@@ -2528,7 +2576,8 @@ struct DawnRenderPassSampleCount : ChainedStruct {
 struct DawnShaderModuleSPIRVOptionsDescriptor : ChainedStruct {
     inline DawnShaderModuleSPIRVOptionsDescriptor();
     struct Init;
-    inline DawnShaderModuleSPIRVOptionsDescriptor(Init&& init);
+    explicit(false) inline DawnShaderModuleSPIRVOptionsDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnShaderModuleSPIRVOptionsDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2539,7 +2588,8 @@ struct DawnShaderModuleSPIRVOptionsDescriptor : ChainedStruct {
 struct DawnTexelCopyBufferRowAlignmentLimits : ChainedStructOut {
     inline DawnTexelCopyBufferRowAlignmentLimits();
     struct Init;
-    inline DawnTexelCopyBufferRowAlignmentLimits(Init&& init);
+    explicit(false) inline DawnTexelCopyBufferRowAlignmentLimits(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnTexelCopyBufferRowAlignmentLimits&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
@@ -2550,7 +2600,8 @@ struct DawnTexelCopyBufferRowAlignmentLimits : ChainedStructOut {
 struct DawnTextureInternalUsageDescriptor : ChainedStruct {
     inline DawnTextureInternalUsageDescriptor();
     struct Init;
-    inline DawnTextureInternalUsageDescriptor(Init&& init);
+    explicit(false) inline DawnTextureInternalUsageDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnTextureInternalUsageDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureUsage));
@@ -2563,7 +2614,8 @@ struct DawnTextureInternalUsageDescriptor : ChainedStruct {
 struct DawnTogglesDescriptor : ChainedStruct {
     inline DawnTogglesDescriptor();
     struct Init;
-    inline DawnTogglesDescriptor(Init&& init);
+    explicit(false) inline DawnTogglesDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnTogglesDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
@@ -2577,7 +2629,8 @@ struct DawnTogglesDescriptor : ChainedStruct {
 struct DawnWGSLBlocklist : ChainedStruct {
     inline DawnWGSLBlocklist();
     struct Init;
-    inline DawnWGSLBlocklist(Init&& init);
+    explicit(false) inline DawnWGSLBlocklist(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnWGSLBlocklist&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(size_t));
@@ -2589,7 +2642,8 @@ struct DawnWGSLBlocklist : ChainedStruct {
 struct DawnWireWGSLControl : ChainedStruct {
     inline DawnWireWGSLControl();
     struct Init;
-    inline DawnWireWGSLControl(Init&& init);
+    explicit(false) inline DawnWireWGSLControl(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnWireWGSLControl&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2602,7 +2656,8 @@ struct DawnWireWGSLControl : ChainedStruct {
 struct EmscriptenSurfaceSourceCanvasHTMLSelector : ChainedStruct {
     inline EmscriptenSurfaceSourceCanvasHTMLSelector();
     struct Init;
-    inline EmscriptenSurfaceSourceCanvasHTMLSelector(Init&& init);
+    explicit(false) inline EmscriptenSurfaceSourceCanvasHTMLSelector(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUEmscriptenSurfaceSourceCanvasHTMLSelector&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
@@ -2610,6 +2665,7 @@ struct EmscriptenSurfaceSourceCanvasHTMLSelector : ChainedStruct {
 };
 
 struct Extent2D {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUExtent2D&() const noexcept;
 
     uint32_t width;
@@ -2617,6 +2673,7 @@ struct Extent2D {
 };
 
 struct Extent3D {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUExtent3D&() const noexcept;
 
     uint32_t width;
@@ -2628,7 +2685,8 @@ struct Extent3D {
 struct ExternalTextureBindingEntry : ChainedStruct {
     inline ExternalTextureBindingEntry();
     struct Init;
-    inline ExternalTextureBindingEntry(Init&& init);
+    explicit(false) inline ExternalTextureBindingEntry(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUExternalTextureBindingEntry&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(ExternalTexture));
@@ -2639,18 +2697,21 @@ struct ExternalTextureBindingEntry : ChainedStruct {
 struct ExternalTextureBindingLayout : ChainedStruct {
     inline ExternalTextureBindingLayout();
     struct Init;
-    inline ExternalTextureBindingLayout(Init&& init);
+    explicit(false) inline ExternalTextureBindingLayout(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUExternalTextureBindingLayout&() const noexcept;
 
     };
 
 struct Future {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUFuture&() const noexcept;
 
     uint64_t id;
 };
 
 struct InstanceLimits {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUInstanceLimits&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -2658,12 +2719,14 @@ struct InstanceLimits {
 };
 
 struct INTERNAL_HAVE_EMDAWNWEBGPU_HEADER {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER&() const noexcept;
 
     Bool unused = false;
 };
 
 struct MemoryHeapInfo {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUMemoryHeapInfo&() const noexcept;
 
     HeapProperty properties = HeapProperty::None;
@@ -2671,6 +2734,7 @@ struct MemoryHeapInfo {
 };
 
 struct MultisampleState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUMultisampleState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2680,6 +2744,7 @@ struct MultisampleState {
 };
 
 struct Origin2D {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUOrigin2D&() const noexcept;
 
     uint32_t x = 0;
@@ -2687,6 +2752,7 @@ struct Origin2D {
 };
 
 struct Origin3D {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUOrigin3D&() const noexcept;
 
     uint32_t x = 0;
@@ -2695,6 +2761,7 @@ struct Origin3D {
 };
 
 struct PassTimestampWrites {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUPassTimestampWrites&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2707,7 +2774,8 @@ struct PassTimestampWrites {
 struct PipelineLayoutResourceTable : ChainedStruct {
     inline PipelineLayoutResourceTable();
     struct Init;
-    inline PipelineLayoutResourceTable(Init&& init);
+    explicit(false) inline PipelineLayoutResourceTable(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUPipelineLayoutResourceTable&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2715,6 +2783,7 @@ struct PipelineLayoutResourceTable : ChainedStruct {
 };
 
 struct PipelineLayoutStorageAttachment {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUPipelineLayoutStorageAttachment&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2723,6 +2792,7 @@ struct PipelineLayoutStorageAttachment {
 };
 
 struct PrimitiveState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUPrimitiveState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2734,6 +2804,7 @@ struct PrimitiveState {
 };
 
 struct QuerySetDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUQuerySetDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2743,6 +2814,7 @@ struct QuerySetDescriptor {
 };
 
 struct QueueDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUQueueDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2750,6 +2822,7 @@ struct QueueDescriptor {
 };
 
 struct RenderBundleDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderBundleDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2757,6 +2830,7 @@ struct RenderBundleDescriptor {
 };
 
 struct RenderBundleEncoderDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderBundleEncoderDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2770,6 +2844,7 @@ struct RenderBundleEncoderDescriptor {
 };
 
 struct RenderPassDepthStencilAttachment {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassDepthStencilAttachment&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2788,7 +2863,8 @@ struct RenderPassDepthStencilAttachment {
 struct RenderPassDescriptorResolveRect : ChainedStruct {
     inline RenderPassDescriptorResolveRect();
     struct Init;
-    inline RenderPassDescriptorResolveRect(Init&& init);
+    explicit(false) inline RenderPassDescriptorResolveRect(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassDescriptorResolveRect&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
@@ -2804,7 +2880,8 @@ struct RenderPassDescriptorResolveRect : ChainedStruct {
 struct RenderPassMaxDrawCount : ChainedStruct {
     inline RenderPassMaxDrawCount();
     struct Init;
-    inline RenderPassMaxDrawCount(Init&& init);
+    explicit(false) inline RenderPassMaxDrawCount(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassMaxDrawCount&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
@@ -2815,7 +2892,8 @@ struct RenderPassMaxDrawCount : ChainedStruct {
 struct RequestAdapterWebGPUBackendOptions : ChainedStruct {
     inline RequestAdapterWebGPUBackendOptions();
     struct Init;
-    inline RequestAdapterWebGPUBackendOptions(Init&& init);
+    explicit(false) inline RequestAdapterWebGPUBackendOptions(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURequestAdapterWebGPUBackendOptions&() const noexcept;
 
     };
@@ -2824,7 +2902,8 @@ struct RequestAdapterWebGPUBackendOptions : ChainedStruct {
 struct RequestAdapterWebXROptions : ChainedStruct {
     inline RequestAdapterWebXROptions();
     struct Init;
-    inline RequestAdapterWebXROptions(Init&& init);
+    explicit(false) inline RequestAdapterWebXROptions(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURequestAdapterWebXROptions&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2832,6 +2911,7 @@ struct RequestAdapterWebXROptions : ChainedStruct {
 };
 
 struct ResourceTableDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUResourceTableDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2840,6 +2920,7 @@ struct ResourceTableDescriptor {
 };
 
 struct SamplerBindingLayout {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSamplerBindingLayout&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2850,7 +2931,8 @@ struct SamplerBindingLayout {
 struct ShaderModuleCompilationOptions : ChainedStruct {
     inline ShaderModuleCompilationOptions();
     struct Init;
-    inline ShaderModuleCompilationOptions(Init&& init);
+    explicit(false) inline ShaderModuleCompilationOptions(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUShaderModuleCompilationOptions&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -2861,7 +2943,8 @@ struct ShaderModuleCompilationOptions : ChainedStruct {
 struct ShaderSourceSPIRV : ChainedStruct {
     inline ShaderSourceSPIRV();
     struct Init;
-    inline ShaderSourceSPIRV(Init&& init);
+    explicit(false) inline ShaderSourceSPIRV(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUShaderSourceSPIRV&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
@@ -2873,7 +2956,8 @@ struct ShaderSourceSPIRV : ChainedStruct {
 struct ShaderSourceWGSL : ChainedStruct {
     inline ShaderSourceWGSL();
     struct Init;
-    inline ShaderSourceWGSL(Init&& init);
+    explicit(false) inline ShaderSourceWGSL(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUShaderSourceWGSL&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(StringView));
@@ -2881,6 +2965,7 @@ struct ShaderSourceWGSL : ChainedStruct {
 };
 
 struct SharedBufferMemoryBeginAccessDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedBufferMemoryBeginAccessDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -2891,18 +2976,6 @@ struct SharedBufferMemoryBeginAccessDescriptor {
     uint64_t const * signaledValues = nullptr;
 };
 
-// Can be chained in SharedBufferMemoryDescriptor
-struct SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor : ChainedStruct {
-    inline SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor();
-    struct Init;
-    inline SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor(Init&& init);
-    inline operator const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor&() const noexcept;
-
-    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
-    alignas(kFirstMemberAlignment) void * handle;
-    uint64_t size;
-};
-
 struct SharedBufferMemoryEndAccessState {
     inline SharedBufferMemoryEndAccessState();
     inline ~SharedBufferMemoryEndAccessState();
@@ -2910,6 +2983,7 @@ struct SharedBufferMemoryEndAccessState {
     SharedBufferMemoryEndAccessState& operator=(const SharedBufferMemoryEndAccessState&) = delete;
     inline SharedBufferMemoryEndAccessState(SharedBufferMemoryEndAccessState&&);
     inline SharedBufferMemoryEndAccessState& operator=(SharedBufferMemoryEndAccessState&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedBufferMemoryEndAccessState&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -2924,7 +2998,21 @@ struct SharedBufferMemoryEndAccessState {
     static inline void Reset(SharedBufferMemoryEndAccessState& value);
 };
 
+// Can be chained in SharedBufferMemoryDescriptor
+struct SharedBufferMemoryFromWindowsHandleDescriptor : ChainedStruct {
+    inline SharedBufferMemoryFromWindowsHandleDescriptor();
+    struct Init;
+    explicit(false) inline SharedBufferMemoryFromWindowsHandleDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    inline operator const WGPUSharedBufferMemoryFromWindowsHandleDescriptor&() const noexcept;
+
+    static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
+    alignas(kFirstMemberAlignment) void * handle;
+    uint64_t size;
+};
+
 struct SharedBufferMemoryProperties {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedBufferMemoryProperties&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -2936,7 +3024,8 @@ struct SharedBufferMemoryProperties {
 struct SharedFenceDXGISharedHandleDescriptor : ChainedStruct {
     inline SharedFenceDXGISharedHandleDescriptor();
     struct Init;
-    inline SharedFenceDXGISharedHandleDescriptor(Init&& init);
+    explicit(false) inline SharedFenceDXGISharedHandleDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceDXGISharedHandleDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -2947,7 +3036,8 @@ struct SharedFenceDXGISharedHandleDescriptor : ChainedStruct {
 struct SharedFenceDXGISharedHandleExportInfo : ChainedStructOut {
     inline SharedFenceDXGISharedHandleExportInfo();
     struct Init;
-    inline SharedFenceDXGISharedHandleExportInfo(Init&& init);
+    explicit(false) inline SharedFenceDXGISharedHandleExportInfo(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceDXGISharedHandleExportInfo&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(void *));
@@ -2958,7 +3048,8 @@ struct SharedFenceDXGISharedHandleExportInfo : ChainedStructOut {
 struct SharedFenceEGLSyncDescriptor : ChainedStruct {
     inline SharedFenceEGLSyncDescriptor();
     struct Init;
-    inline SharedFenceEGLSyncDescriptor(Init&& init);
+    explicit(false) inline SharedFenceEGLSyncDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceEGLSyncDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -2969,7 +3060,8 @@ struct SharedFenceEGLSyncDescriptor : ChainedStruct {
 struct SharedFenceEGLSyncExportInfo : ChainedStructOut {
     inline SharedFenceEGLSyncExportInfo();
     struct Init;
-    inline SharedFenceEGLSyncExportInfo(Init&& init);
+    explicit(false) inline SharedFenceEGLSyncExportInfo(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceEGLSyncExportInfo&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(void *));
@@ -2980,7 +3072,8 @@ struct SharedFenceEGLSyncExportInfo : ChainedStructOut {
 struct SharedFenceMTLSharedEventDescriptor : ChainedStruct {
     inline SharedFenceMTLSharedEventDescriptor();
     struct Init;
-    inline SharedFenceMTLSharedEventDescriptor(Init&& init);
+    explicit(false) inline SharedFenceMTLSharedEventDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceMTLSharedEventDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -2991,7 +3084,8 @@ struct SharedFenceMTLSharedEventDescriptor : ChainedStruct {
 struct SharedFenceMTLSharedEventExportInfo : ChainedStructOut {
     inline SharedFenceMTLSharedEventExportInfo();
     struct Init;
-    inline SharedFenceMTLSharedEventExportInfo(Init&& init);
+    explicit(false) inline SharedFenceMTLSharedEventExportInfo(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceMTLSharedEventExportInfo&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(void *));
@@ -3002,7 +3096,8 @@ struct SharedFenceMTLSharedEventExportInfo : ChainedStructOut {
 struct SharedFenceSyncFDDescriptor : ChainedStruct {
     inline SharedFenceSyncFDDescriptor();
     struct Init;
-    inline SharedFenceSyncFDDescriptor(Init&& init);
+    explicit(false) inline SharedFenceSyncFDDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceSyncFDDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
@@ -3013,7 +3108,8 @@ struct SharedFenceSyncFDDescriptor : ChainedStruct {
 struct SharedFenceSyncFDExportInfo : ChainedStructOut {
     inline SharedFenceSyncFDExportInfo();
     struct Init;
-    inline SharedFenceSyncFDExportInfo(Init&& init);
+    explicit(false) inline SharedFenceSyncFDExportInfo(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceSyncFDExportInfo&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(int));
@@ -3024,7 +3120,8 @@ struct SharedFenceSyncFDExportInfo : ChainedStructOut {
 struct SharedFenceVkSemaphoreOpaqueFDDescriptor : ChainedStruct {
     inline SharedFenceVkSemaphoreOpaqueFDDescriptor();
     struct Init;
-    inline SharedFenceVkSemaphoreOpaqueFDDescriptor(Init&& init);
+    explicit(false) inline SharedFenceVkSemaphoreOpaqueFDDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int));
@@ -3035,7 +3132,8 @@ struct SharedFenceVkSemaphoreOpaqueFDDescriptor : ChainedStruct {
 struct SharedFenceVkSemaphoreOpaqueFDExportInfo : ChainedStructOut {
     inline SharedFenceVkSemaphoreOpaqueFDExportInfo();
     struct Init;
-    inline SharedFenceVkSemaphoreOpaqueFDExportInfo(Init&& init);
+    explicit(false) inline SharedFenceVkSemaphoreOpaqueFDExportInfo(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(int));
@@ -3046,7 +3144,8 @@ struct SharedFenceVkSemaphoreOpaqueFDExportInfo : ChainedStructOut {
 struct SharedFenceVkSemaphoreZirconHandleDescriptor : ChainedStruct {
     inline SharedFenceVkSemaphoreZirconHandleDescriptor();
     struct Init;
-    inline SharedFenceVkSemaphoreZirconHandleDescriptor(Init&& init);
+    explicit(false) inline SharedFenceVkSemaphoreZirconHandleDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceVkSemaphoreZirconHandleDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
@@ -3057,7 +3156,8 @@ struct SharedFenceVkSemaphoreZirconHandleDescriptor : ChainedStruct {
 struct SharedFenceVkSemaphoreZirconHandleExportInfo : ChainedStructOut {
     inline SharedFenceVkSemaphoreZirconHandleExportInfo();
     struct Init;
-    inline SharedFenceVkSemaphoreZirconHandleExportInfo(Init&& init);
+    explicit(false) inline SharedFenceVkSemaphoreZirconHandleExportInfo(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceVkSemaphoreZirconHandleExportInfo&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(uint32_t));
@@ -3068,7 +3168,8 @@ struct SharedFenceVkSemaphoreZirconHandleExportInfo : ChainedStructOut {
 struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct {
     inline SharedTextureMemoryAHardwareBufferDescriptor();
     struct Init;
-    inline SharedTextureMemoryAHardwareBufferDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryAHardwareBufferDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryAHardwareBufferDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3079,7 +3180,8 @@ struct SharedTextureMemoryAHardwareBufferDescriptor : ChainedStruct {
 struct SharedTextureMemoryD3D11BeginState : ChainedStruct {
     inline SharedTextureMemoryD3D11BeginState();
     struct Init;
-    inline SharedTextureMemoryD3D11BeginState(Init&& init);
+    explicit(false) inline SharedTextureMemoryD3D11BeginState(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryD3D11BeginState&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -3090,7 +3192,8 @@ struct SharedTextureMemoryD3D11BeginState : ChainedStruct {
 struct SharedTextureMemoryD3DSwapchainBeginState : ChainedStruct {
     inline SharedTextureMemoryD3DSwapchainBeginState();
     struct Init;
-    inline SharedTextureMemoryD3DSwapchainBeginState(Init&& init);
+    explicit(false) inline SharedTextureMemoryD3DSwapchainBeginState(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryD3DSwapchainBeginState&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -3098,6 +3201,7 @@ struct SharedTextureMemoryD3DSwapchainBeginState : ChainedStruct {
 };
 
 struct SharedTextureMemoryDmaBufPlane {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryDmaBufPlane&() const noexcept;
 
     int fd;
@@ -3109,7 +3213,8 @@ struct SharedTextureMemoryDmaBufPlane {
 struct SharedTextureMemoryDXGISharedHandleDescriptor : ChainedStruct {
     inline SharedTextureMemoryDXGISharedHandleDescriptor();
     struct Init;
-    inline SharedTextureMemoryDXGISharedHandleDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryDXGISharedHandleDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryDXGISharedHandleDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3121,7 +3226,8 @@ struct SharedTextureMemoryDXGISharedHandleDescriptor : ChainedStruct {
 struct SharedTextureMemoryEGLImageDescriptor : ChainedStruct {
     inline SharedTextureMemoryEGLImageDescriptor();
     struct Init;
-    inline SharedTextureMemoryEGLImageDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryEGLImageDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryEGLImageDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3132,7 +3238,8 @@ struct SharedTextureMemoryEGLImageDescriptor : ChainedStruct {
 struct SharedTextureMemoryIOSurfaceDescriptor : ChainedStruct {
     inline SharedTextureMemoryIOSurfaceDescriptor();
     struct Init;
-    inline SharedTextureMemoryIOSurfaceDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryIOSurfaceDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryIOSurfaceDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3144,7 +3251,8 @@ struct SharedTextureMemoryIOSurfaceDescriptor : ChainedStruct {
 struct SharedTextureMemoryOpaqueFDDescriptor : ChainedStruct {
     inline SharedTextureMemoryOpaqueFDDescriptor();
     struct Init;
-    inline SharedTextureMemoryOpaqueFDDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryOpaqueFDDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryOpaqueFDDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void const *));
@@ -3159,7 +3267,8 @@ struct SharedTextureMemoryOpaqueFDDescriptor : ChainedStruct {
 struct SharedTextureMemoryVkDedicatedAllocationDescriptor : ChainedStruct {
     inline SharedTextureMemoryVkDedicatedAllocationDescriptor();
     struct Init;
-    inline SharedTextureMemoryVkDedicatedAllocationDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryVkDedicatedAllocationDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Bool));
@@ -3170,7 +3279,8 @@ struct SharedTextureMemoryVkDedicatedAllocationDescriptor : ChainedStruct {
 struct SharedTextureMemoryVkImageLayoutBeginState : ChainedStruct {
     inline SharedTextureMemoryVkImageLayoutBeginState();
     struct Init;
-    inline SharedTextureMemoryVkImageLayoutBeginState(Init&& init);
+    explicit(false) inline SharedTextureMemoryVkImageLayoutBeginState(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryVkImageLayoutBeginState&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(int32_t));
@@ -3182,7 +3292,8 @@ struct SharedTextureMemoryVkImageLayoutBeginState : ChainedStruct {
 struct SharedTextureMemoryVkImageLayoutEndState : ChainedStructOut {
     inline SharedTextureMemoryVkImageLayoutEndState();
     struct Init;
-    inline SharedTextureMemoryVkImageLayoutEndState(Init&& init);
+    explicit(false) inline SharedTextureMemoryVkImageLayoutEndState(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryVkImageLayoutEndState&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(int32_t));
@@ -3194,7 +3305,8 @@ struct SharedTextureMemoryVkImageLayoutEndState : ChainedStructOut {
 struct SharedTextureMemoryZirconHandleDescriptor : ChainedStruct {
     inline SharedTextureMemoryZirconHandleDescriptor();
     struct Init;
-    inline SharedTextureMemoryZirconHandleDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryZirconHandleDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryZirconHandleDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
@@ -3206,7 +3318,8 @@ struct SharedTextureMemoryZirconHandleDescriptor : ChainedStruct {
 struct StaticSamplerBindingLayout : ChainedStruct {
     inline StaticSamplerBindingLayout();
     struct Init;
-    inline StaticSamplerBindingLayout(Init&& init);
+    explicit(false) inline StaticSamplerBindingLayout(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUStaticSamplerBindingLayout&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Sampler));
@@ -3215,6 +3328,7 @@ struct StaticSamplerBindingLayout : ChainedStruct {
 };
 
 struct StencilFaceState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUStencilFaceState&() const noexcept;
 
     CompareFunction compare = CompareFunction::Undefined;
@@ -3224,6 +3338,7 @@ struct StencilFaceState {
 };
 
 struct StorageTextureBindingLayout {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUStorageTextureBindingLayout&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3233,6 +3348,7 @@ struct StorageTextureBindingLayout {
 };
 
 struct SubgroupMatrixConfig {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSubgroupMatrixConfig&() const noexcept;
 
     SubgroupMatrixComponentType componentType = {};
@@ -3249,6 +3365,7 @@ struct SupportedFeatures {
     SupportedFeatures& operator=(const SupportedFeatures&) = delete;
     inline SupportedFeatures(SupportedFeatures&&);
     inline SupportedFeatures& operator=(SupportedFeatures&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSupportedFeatures&() const noexcept;
 
     size_t const featureCount = {};
@@ -3266,6 +3383,7 @@ struct SupportedInstanceFeatures {
     SupportedInstanceFeatures& operator=(const SupportedInstanceFeatures&) = delete;
     inline SupportedInstanceFeatures(SupportedInstanceFeatures&&);
     inline SupportedInstanceFeatures& operator=(SupportedInstanceFeatures&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSupportedInstanceFeatures&() const noexcept;
 
     size_t const featureCount = {};
@@ -3283,6 +3401,7 @@ struct SupportedWGSLLanguageFeatures {
     SupportedWGSLLanguageFeatures& operator=(const SupportedWGSLLanguageFeatures&) = delete;
     inline SupportedWGSLLanguageFeatures(SupportedWGSLLanguageFeatures&&);
     inline SupportedWGSLLanguageFeatures& operator=(SupportedWGSLLanguageFeatures&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSupportedWGSLLanguageFeatures&() const noexcept;
 
     size_t const featureCount = {};
@@ -3300,6 +3419,7 @@ struct SurfaceCapabilities {
     SurfaceCapabilities& operator=(const SurfaceCapabilities&) = delete;
     inline SurfaceCapabilities(SurfaceCapabilities&&);
     inline SurfaceCapabilities& operator=(SurfaceCapabilities&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceCapabilities&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -3320,7 +3440,8 @@ struct SurfaceCapabilities {
 struct SurfaceColorManagement : ChainedStruct {
     inline SurfaceColorManagement();
     struct Init;
-    inline SurfaceColorManagement(Init&& init);
+    explicit(false) inline SurfaceColorManagement(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceColorManagement&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(PredefinedColorSpace));
@@ -3329,6 +3450,7 @@ struct SurfaceColorManagement : ChainedStruct {
 };
 
 struct SurfaceConfiguration {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceConfiguration&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3347,7 +3469,8 @@ struct SurfaceConfiguration {
 struct SurfaceDescriptorFromWindowsCoreWindow : ChainedStruct {
     inline SurfaceDescriptorFromWindowsCoreWindow();
     struct Init;
-    inline SurfaceDescriptorFromWindowsCoreWindow(Init&& init);
+    explicit(false) inline SurfaceDescriptorFromWindowsCoreWindow(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceDescriptorFromWindowsCoreWindow&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3358,7 +3481,8 @@ struct SurfaceDescriptorFromWindowsCoreWindow : ChainedStruct {
 struct SurfaceDescriptorFromWindowsUWPSwapChainPanel : ChainedStruct {
     inline SurfaceDescriptorFromWindowsUWPSwapChainPanel();
     struct Init;
-    inline SurfaceDescriptorFromWindowsUWPSwapChainPanel(Init&& init);
+    explicit(false) inline SurfaceDescriptorFromWindowsUWPSwapChainPanel(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3369,7 +3493,8 @@ struct SurfaceDescriptorFromWindowsUWPSwapChainPanel : ChainedStruct {
 struct SurfaceDescriptorFromWindowsWinUISwapChainPanel : ChainedStruct {
     inline SurfaceDescriptorFromWindowsWinUISwapChainPanel();
     struct Init;
-    inline SurfaceDescriptorFromWindowsWinUISwapChainPanel(Init&& init);
+    explicit(false) inline SurfaceDescriptorFromWindowsWinUISwapChainPanel(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3380,7 +3505,8 @@ struct SurfaceDescriptorFromWindowsWinUISwapChainPanel : ChainedStruct {
 struct SurfaceSourceAndroidNativeWindow : ChainedStruct {
     inline SurfaceSourceAndroidNativeWindow();
     struct Init;
-    inline SurfaceSourceAndroidNativeWindow(Init&& init);
+    explicit(false) inline SurfaceSourceAndroidNativeWindow(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceSourceAndroidNativeWindow&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3391,7 +3517,8 @@ struct SurfaceSourceAndroidNativeWindow : ChainedStruct {
 struct SurfaceSourceMetalLayer : ChainedStruct {
     inline SurfaceSourceMetalLayer();
     struct Init;
-    inline SurfaceSourceMetalLayer(Init&& init);
+    explicit(false) inline SurfaceSourceMetalLayer(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceSourceMetalLayer&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3402,7 +3529,8 @@ struct SurfaceSourceMetalLayer : ChainedStruct {
 struct SurfaceSourceWaylandSurface : ChainedStruct {
     inline SurfaceSourceWaylandSurface();
     struct Init;
-    inline SurfaceSourceWaylandSurface(Init&& init);
+    explicit(false) inline SurfaceSourceWaylandSurface(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceSourceWaylandSurface&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3414,7 +3542,8 @@ struct SurfaceSourceWaylandSurface : ChainedStruct {
 struct SurfaceSourceWindowsHWND : ChainedStruct {
     inline SurfaceSourceWindowsHWND();
     struct Init;
-    inline SurfaceSourceWindowsHWND(Init&& init);
+    explicit(false) inline SurfaceSourceWindowsHWND(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceSourceWindowsHWND&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3426,7 +3555,8 @@ struct SurfaceSourceWindowsHWND : ChainedStruct {
 struct SurfaceSourceXCBWindow : ChainedStruct {
     inline SurfaceSourceXCBWindow();
     struct Init;
-    inline SurfaceSourceXCBWindow(Init&& init);
+    explicit(false) inline SurfaceSourceXCBWindow(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceSourceXCBWindow&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3438,7 +3568,8 @@ struct SurfaceSourceXCBWindow : ChainedStruct {
 struct SurfaceSourceXlibWindow : ChainedStruct {
     inline SurfaceSourceXlibWindow();
     struct Init;
-    inline SurfaceSourceXlibWindow(Init&& init);
+    explicit(false) inline SurfaceSourceXlibWindow(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceSourceXlibWindow&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(void *));
@@ -3447,6 +3578,7 @@ struct SurfaceSourceXlibWindow : ChainedStruct {
 };
 
 struct SurfaceTexture {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceTexture&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -3458,7 +3590,8 @@ struct SurfaceTexture {
 struct TexelBufferBindingEntry : ChainedStruct {
     inline TexelBufferBindingEntry();
     struct Init;
-    inline TexelBufferBindingEntry(Init&& init);
+    explicit(false) inline TexelBufferBindingEntry(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTexelBufferBindingEntry&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TexelBufferView));
@@ -3469,7 +3602,8 @@ struct TexelBufferBindingEntry : ChainedStruct {
 struct TexelBufferBindingLayout : ChainedStruct {
     inline TexelBufferBindingLayout();
     struct Init;
-    inline TexelBufferBindingLayout(Init&& init);
+    explicit(false) inline TexelBufferBindingLayout(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTexelBufferBindingLayout&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TexelBufferAccess));
@@ -3478,6 +3612,7 @@ struct TexelBufferBindingLayout : ChainedStruct {
 };
 
 struct TexelBufferViewDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTexelBufferViewDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3488,6 +3623,7 @@ struct TexelBufferViewDescriptor {
 };
 
 struct TexelCopyBufferLayout {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTexelCopyBufferLayout&() const noexcept;
 
     uint64_t offset = 0;
@@ -3496,6 +3632,7 @@ struct TexelCopyBufferLayout {
 };
 
 struct TextureBindingLayout {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTextureBindingLayout&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3508,7 +3645,8 @@ struct TextureBindingLayout {
 struct TextureBindingViewDimension : ChainedStruct {
     inline TextureBindingViewDimension();
     struct Init;
-    inline TextureBindingViewDimension(Init&& init);
+    explicit(false) inline TextureBindingViewDimension(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTextureBindingViewDimension&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureViewDimension));
@@ -3516,6 +3654,7 @@ struct TextureBindingViewDimension : ChainedStruct {
 };
 
 struct TextureComponentSwizzle {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTextureComponentSwizzle&() const noexcept;
 
     ComponentSwizzle r = ComponentSwizzle::Undefined;
@@ -3525,6 +3664,7 @@ struct TextureComponentSwizzle {
 };
 
 struct VertexAttribute {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUVertexAttribute&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3538,7 +3678,8 @@ struct VertexAttribute {
 struct YCbCrVkDescriptor : ChainedStruct {
     inline YCbCrVkDescriptor();
     struct Init;
-    inline YCbCrVkDescriptor(Init&& init);
+    explicit(false) inline YCbCrVkDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUYCbCrVkDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint32_t));
@@ -3560,12 +3701,13 @@ struct YCbCrVkDescriptor : ChainedStruct {
 struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
     inline AdapterPropertiesMemoryHeaps();
     struct Init;
-    inline AdapterPropertiesMemoryHeaps(Init&& init);
+    explicit(false) inline AdapterPropertiesMemoryHeaps(Init&& init);
     inline ~AdapterPropertiesMemoryHeaps();
     AdapterPropertiesMemoryHeaps(const AdapterPropertiesMemoryHeaps&) = delete;
     AdapterPropertiesMemoryHeaps& operator=(const AdapterPropertiesMemoryHeaps&) = delete;
     inline AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps&&);
     inline AdapterPropertiesMemoryHeaps& operator=(AdapterPropertiesMemoryHeaps&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterPropertiesMemoryHeaps&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(size_t));
@@ -3581,12 +3723,13 @@ struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
 struct AdapterPropertiesSubgroupMatrixConfigs : ChainedStructOut {
     inline AdapterPropertiesSubgroupMatrixConfigs();
     struct Init;
-    inline AdapterPropertiesSubgroupMatrixConfigs(Init&& init);
+    explicit(false) inline AdapterPropertiesSubgroupMatrixConfigs(Init&& init);
     inline ~AdapterPropertiesSubgroupMatrixConfigs();
     AdapterPropertiesSubgroupMatrixConfigs(const AdapterPropertiesSubgroupMatrixConfigs&) = delete;
     AdapterPropertiesSubgroupMatrixConfigs& operator=(const AdapterPropertiesSubgroupMatrixConfigs&) = delete;
     inline AdapterPropertiesSubgroupMatrixConfigs(AdapterPropertiesSubgroupMatrixConfigs&&);
     inline AdapterPropertiesSubgroupMatrixConfigs& operator=(AdapterPropertiesSubgroupMatrixConfigs&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterPropertiesSubgroupMatrixConfigs&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(size_t));
@@ -3599,12 +3742,14 @@ struct AdapterPropertiesSubgroupMatrixConfigs : ChainedStructOut {
 };
 
 struct AHardwareBufferProperties {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAHardwareBufferProperties&() const noexcept;
 
     YCbCrVkDescriptor yCbCrInfo = {};
 };
 
 struct BindGroupEntry {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBindGroupEntry&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3617,6 +3762,7 @@ struct BindGroupEntry {
 };
 
 struct BindGroupLayoutEntry {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBindGroupLayoutEntry&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3630,6 +3776,7 @@ struct BindGroupLayoutEntry {
 };
 
 struct BlendState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBlendState&() const noexcept;
 
     BlendComponent color = {};
@@ -3637,6 +3784,7 @@ struct BlendState {
 };
 
 struct BufferDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBufferDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3647,6 +3795,7 @@ struct BufferDescriptor {
 };
 
 struct CommandEncoderDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUCommandEncoderDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3654,6 +3803,7 @@ struct CommandEncoderDescriptor {
 };
 
 struct CompilationMessage {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUCompilationMessage&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3666,6 +3816,7 @@ struct CompilationMessage {
 };
 
 struct ComputePassDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUComputePassDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3674,6 +3825,7 @@ struct ComputePassDescriptor {
 };
 
 struct ComputeState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUComputeState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3687,12 +3839,13 @@ struct ComputeState {
 struct DawnDrmFormatCapabilities : ChainedStructOut {
     inline DawnDrmFormatCapabilities();
     struct Init;
-    inline DawnDrmFormatCapabilities(Init&& init);
+    explicit(false) inline DawnDrmFormatCapabilities(Init&& init);
     inline ~DawnDrmFormatCapabilities();
     DawnDrmFormatCapabilities(const DawnDrmFormatCapabilities&) = delete;
     DawnDrmFormatCapabilities& operator=(const DawnDrmFormatCapabilities&) = delete;
     inline DawnDrmFormatCapabilities(DawnDrmFormatCapabilities&&);
     inline DawnDrmFormatCapabilities& operator=(DawnDrmFormatCapabilities&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnDrmFormatCapabilities&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(size_t));
@@ -3705,6 +3858,7 @@ struct DawnDrmFormatCapabilities : ChainedStructOut {
 };
 
 struct DepthStencilState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDepthStencilState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3721,6 +3875,7 @@ struct DepthStencilState {
 };
 
 struct ExternalTextureDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUExternalTextureDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3740,6 +3895,7 @@ struct ExternalTextureDescriptor {
 };
 
 struct FutureWaitInfo {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUFutureWaitInfo&() const noexcept;
 
     Future future = {};
@@ -3747,6 +3903,7 @@ struct FutureWaitInfo {
 };
 
 struct ImageCopyExternalTexture {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUImageCopyExternalTexture&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3756,6 +3913,7 @@ struct ImageCopyExternalTexture {
 };
 
 struct InstanceDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUInstanceDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3765,6 +3923,7 @@ struct InstanceDescriptor {
 };
 
 struct Limits {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPULimits&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -3806,7 +3965,8 @@ struct Limits {
 struct PipelineLayoutPixelLocalStorage : ChainedStruct {
     inline PipelineLayoutPixelLocalStorage();
     struct Init;
-    inline PipelineLayoutPixelLocalStorage(Init&& init);
+    explicit(false) inline PipelineLayoutPixelLocalStorage(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUPipelineLayoutPixelLocalStorage&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
@@ -3816,6 +3976,7 @@ struct PipelineLayoutPixelLocalStorage : ChainedStruct {
 };
 
 struct RenderPassColorAttachment {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassColorAttachment&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3831,7 +3992,8 @@ struct RenderPassColorAttachment {
 struct RenderPassRenderAreaRect : ChainedStruct {
     inline RenderPassRenderAreaRect();
     struct Init;
-    inline RenderPassRenderAreaRect(Init&& init);
+    explicit(false) inline RenderPassRenderAreaRect(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassRenderAreaRect&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Origin2D));
@@ -3840,6 +4002,7 @@ struct RenderPassRenderAreaRect : ChainedStruct {
 };
 
 struct RenderPassStorageAttachment {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassStorageAttachment&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3851,6 +4014,7 @@ struct RenderPassStorageAttachment {
 };
 
 struct RequestAdapterOptions {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURequestAdapterOptions&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3862,6 +4026,7 @@ struct RequestAdapterOptions {
 };
 
 struct SamplerDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSamplerDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3879,6 +4044,7 @@ struct SamplerDescriptor {
 };
 
 struct ShaderModuleDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUShaderModuleDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3886,6 +4052,7 @@ struct ShaderModuleDescriptor {
 };
 
 struct SharedBufferMemoryDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedBufferMemoryDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3893,6 +4060,7 @@ struct SharedBufferMemoryDescriptor {
 };
 
 struct SharedFenceDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3900,6 +4068,7 @@ struct SharedFenceDescriptor {
 };
 
 struct SharedFenceExportInfo {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedFenceExportInfo&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -3910,7 +4079,8 @@ struct SharedFenceExportInfo {
 struct SharedTextureMemoryAHardwareBufferProperties : ChainedStructOut {
     inline SharedTextureMemoryAHardwareBufferProperties();
     struct Init;
-    inline SharedTextureMemoryAHardwareBufferProperties(Init&& init);
+    explicit(false) inline SharedTextureMemoryAHardwareBufferProperties(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryAHardwareBufferProperties&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(YCbCrVkDescriptor));
@@ -3918,6 +4088,7 @@ struct SharedTextureMemoryAHardwareBufferProperties : ChainedStructOut {
 };
 
 struct SharedTextureMemoryBeginAccessDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryBeginAccessDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3933,7 +4104,8 @@ struct SharedTextureMemoryBeginAccessDescriptor {
 struct SharedTextureMemoryDmaBufDescriptor : ChainedStruct {
     inline SharedTextureMemoryDmaBufDescriptor();
     struct Init;
-    inline SharedTextureMemoryDmaBufDescriptor(Init&& init);
+    explicit(false) inline SharedTextureMemoryDmaBufDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryDmaBufDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(Extent3D));
@@ -3948,7 +4120,8 @@ struct SharedTextureMemoryDmaBufDescriptor : ChainedStruct {
 struct SharedTextureMemoryMetalEndAccessState : ChainedStructOut {
     inline SharedTextureMemoryMetalEndAccessState();
     struct Init;
-    inline SharedTextureMemoryMetalEndAccessState(Init&& init);
+    explicit(false) inline SharedTextureMemoryMetalEndAccessState(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryMetalEndAccessState&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStructOut), alignof(Future));
@@ -3956,6 +4129,7 @@ struct SharedTextureMemoryMetalEndAccessState : ChainedStructOut {
 };
 
 struct SurfaceDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSurfaceDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -3963,6 +4137,7 @@ struct SurfaceDescriptor {
 };
 
 struct TexelCopyBufferInfo {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTexelCopyBufferInfo&() const noexcept;
 
     TexelCopyBufferLayout layout = {};
@@ -3970,6 +4145,7 @@ struct TexelCopyBufferInfo {
 };
 
 struct TexelCopyTextureInfo {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTexelCopyTextureInfo&() const noexcept;
 
     Texture texture = nullptr;
@@ -3982,7 +4158,8 @@ struct TexelCopyTextureInfo {
 struct TextureComponentSwizzleDescriptor : ChainedStruct {
     inline TextureComponentSwizzleDescriptor();
     struct Init;
-    inline TextureComponentSwizzleDescriptor(Init&& init);
+    explicit(false) inline TextureComponentSwizzleDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTextureComponentSwizzleDescriptor&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(TextureComponentSwizzle));
@@ -3990,6 +4167,7 @@ struct TextureComponentSwizzleDescriptor : ChainedStruct {
 };
 
 struct TextureDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTextureDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4005,6 +4183,7 @@ struct TextureDescriptor {
 };
 
 struct VertexBufferLayout {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUVertexBufferLayout&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4021,6 +4200,7 @@ struct AdapterInfo {
     AdapterInfo& operator=(const AdapterInfo&) = delete;
     inline AdapterInfo(AdapterInfo&&);
     inline AdapterInfo& operator=(AdapterInfo&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUAdapterInfo&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -4041,6 +4221,7 @@ struct AdapterInfo {
 };
 
 struct BindGroupDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBindGroupDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4051,6 +4232,7 @@ struct BindGroupDescriptor {
 };
 
 struct BindGroupLayoutDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUBindGroupLayoutDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4060,6 +4242,7 @@ struct BindGroupLayoutDescriptor {
 };
 
 struct ColorTargetState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUColorTargetState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4069,6 +4252,7 @@ struct ColorTargetState {
 };
 
 struct CompilationInfo {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUCompilationInfo&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4077,6 +4261,7 @@ struct CompilationInfo {
 };
 
 struct ComputePipelineDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUComputePipelineDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4086,6 +4271,7 @@ struct ComputePipelineDescriptor {
 };
 
 struct DawnFormatCapabilities {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDawnFormatCapabilities&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -4106,7 +4292,8 @@ struct DeviceDescriptor {
 struct DeviceDescriptor : protected detail::DeviceDescriptor {
     inline DeviceDescriptor();
     struct Init;
-    inline DeviceDescriptor(Init&& init);
+    explicit(false) inline DeviceDescriptor(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUDeviceDescriptor&() const noexcept;
 
     using detail::DeviceDescriptor::nextInChain;
@@ -4127,6 +4314,7 @@ struct DeviceDescriptor : protected detail::DeviceDescriptor {
 };
 
 struct PipelineLayoutDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUPipelineLayoutDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4140,7 +4328,8 @@ struct PipelineLayoutDescriptor {
 struct RenderPassPixelLocalStorage : ChainedStruct {
     inline RenderPassPixelLocalStorage();
     struct Init;
-    inline RenderPassPixelLocalStorage(Init&& init);
+    explicit(false) inline RenderPassPixelLocalStorage(Init&& init);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassPixelLocalStorage&() const noexcept;
 
     static constexpr size_t kFirstMemberAlignment = detail::ConstexprMax(alignof(ChainedStruct), alignof(uint64_t));
@@ -4150,6 +4339,7 @@ struct RenderPassPixelLocalStorage : ChainedStruct {
 };
 
 struct SharedTextureMemoryDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4163,6 +4353,7 @@ struct SharedTextureMemoryEndAccessState {
     SharedTextureMemoryEndAccessState& operator=(const SharedTextureMemoryEndAccessState&) = delete;
     inline SharedTextureMemoryEndAccessState(SharedTextureMemoryEndAccessState&&);
     inline SharedTextureMemoryEndAccessState& operator=(SharedTextureMemoryEndAccessState&&);
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryEndAccessState&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -4178,6 +4369,7 @@ struct SharedTextureMemoryEndAccessState {
 };
 
 struct SharedTextureMemoryProperties {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUSharedTextureMemoryProperties&() const noexcept;
 
     ChainedStructOut  * nextInChain = nullptr;
@@ -4187,6 +4379,7 @@ struct SharedTextureMemoryProperties {
 };
 
 struct TextureViewDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUTextureViewDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4202,6 +4395,7 @@ struct TextureViewDescriptor {
 };
 
 struct VertexState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUVertexState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4214,6 +4408,7 @@ struct VertexState {
 };
 
 struct FragmentState {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPUFragmentState&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4226,6 +4421,7 @@ struct FragmentState {
 };
 
 struct RenderPassDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPassDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4238,6 +4434,7 @@ struct RenderPassDescriptor {
 };
 
 struct RenderPipelineDescriptor {
+    // NOLINTNEXTLINE(google-explicit-constructor)
     inline operator const WGPURenderPipelineDescriptor&() const noexcept;
 
     ChainedStruct const * nextInChain = nullptr;
@@ -4250,6 +4447,7 @@ struct RenderPipelineDescriptor {
     FragmentState const * fragment = nullptr;
 };
 
+// NOLINTEND(bugprone-invalid-enum-default-initialization)
 
 // Callback info handling is generated and/or custom implemented here to convert the types between C and C++.
 namespace detail {
@@ -4259,6 +4457,7 @@ struct Untyped {};
 //   - 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::ReturnT: The return type of the C++ callback function pointer.
 //   - CppFTraits::BaseArgsTuple: A tuple of the C++ arguments minus the user specified typed
 //     parameter.
 //
@@ -4272,10 +4471,24 @@ struct CppFTraitsImpl;
 template <typename CppFT, typename R, typename... CppArgs, typename T>
 struct CppFTraitsImpl<CppFT, R(*)(CppArgs...), T> {
     using PtrT = R(*)(CppArgs...);
+    using ReturnT = R;
     static constexpr bool capturing = false;
 
     static constexpr size_t NumCppArgs = sizeof...(CppArgs);
-    using BaseArgsTuple = typename decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
+    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 noexcept raw function pointers.
+template <typename CppFT, typename R, typename... CppArgs, typename T>
+struct CppFTraitsImpl<CppFT, R(*)(CppArgs...) noexcept, T> {
+    using PtrT = R(*)(CppArgs...) noexcept;
+    using ReturnT = R;
+    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;
@@ -4284,10 +4497,24 @@ struct CppFTraitsImpl<CppFT, R(*)(CppArgs...), T> {
 template <typename CppFT, typename R, typename C, typename... CppArgs, typename T>
 struct CppFTraitsImpl<CppFT, R(C::*)(CppArgs...) const, T> {
     using PtrT = R(*)(CppArgs...);
+    using ReturnT = R;
+    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;
+};
+// Specialization for noexcept member function pointers (noexcept lambdas);
+template <typename CppFT, typename R, typename C, typename... CppArgs, typename T>
+struct CppFTraitsImpl<CppFT, R(C::*)(CppArgs...) const noexcept, T> {
+    using PtrT = R(*)(CppArgs...) noexcept;
+    using ReturnT = R;
     static constexpr bool capturing = !std::is_convertible_v<CppFT, PtrT>;
 
     static constexpr size_t NumCppArgs = sizeof...(CppArgs);
-    using BaseArgsTuple = typename decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
+    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;
@@ -4297,6 +4524,9 @@ 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> {};
+template <typename R, typename... CppArgs, typename T>
+struct CppFTraits<R(*)(CppArgs...) noexcept, T> :
+    CppFTraitsImpl<R(*)(CppArgs...) noexcept, R(*)(CppArgs...) noexcept, 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
@@ -4411,28 +4641,50 @@ struct CArgConverter<WGPUUncapturedErrorCallbackInfo,
                                static_cast<ErrorType>(type), message);
     }
 };
+template <>
+struct CArgConverter<WGPUDawnLoadCacheDataCallbackInfo,
+                     std::tuple<std::span<const std::byte>, std::span<std::byte>>> {
+    using Result = std::tuple<std::span<const std::byte>, std::span<std::byte>>;
+    static Result Convert(size_t keySize, uint8_t const* key, size_t valueSize, uint8_t* value) {
+        return std::make_tuple(
+            std::span<const std::byte>(reinterpret_cast<const std::byte*>(key), keySize),
+            std::span<std::byte>(reinterpret_cast<std::byte*>(value), valueSize)
+        );
+    }
+};
+template <>
+struct CArgConverter<WGPUDawnStoreCacheDataCallbackInfo,
+                     std::tuple<std::span<const std::byte>, std::span<const std::byte>>> {
+    using Result = std::tuple<std::span<const std::byte>, std::span<const std::byte>>;
+    static Result Convert(size_t keySize, uint8_t const* key, size_t valueSize, uint8_t const* value) {
+        return std::make_tuple(
+            std::span<const std::byte>(reinterpret_cast<const std::byte*>(key), keySize),
+            std::span<const std::byte>(reinterpret_cast<const std::byte*>(value), valueSize)
+        );
+    }
+};
 
 // 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>
+template <typename R, 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...>> {
+template <typename R, typename CInfoT, typename CppF, typename... CArgs, std::size_t... Is>
+struct CallbackHelperImpl<R, 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,
+    static R 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...));
+            return std::apply(*callback, Converter::Convert(cArgs...));
         } else {
-            auto callback = reinterpret_cast<typename CppFTraits::PtrT>(callbackParam);
-            std::apply(callback, Converter::Convert(cArgs...));
+            auto callback = reinterpret_cast<CppFTraits::PtrT>(callbackParam);
+            return std::apply(callback, Converter::Convert(cArgs...));
         }
     }
 
@@ -4441,20 +4693,20 @@ struct CallbackHelperImpl<CInfoT, CppF, std::tuple<CArgs...>, std::index_sequenc
     // 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,
+    static R 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 callback = reinterpret_cast<CppFTraits::PtrT>(callbackParam);
         auto param = std::make_tuple(static_cast<T>(userdataParam));
-        std::apply(callback, std::tuple_cat(Converter::Convert(cArgs...), param));
+        return 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...)> {
+template <typename CInfoT, typename F, typename R, typename... CArgs>
+struct CallbackHelper<CInfoT, F, R(*)(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.");
@@ -4467,13 +4719,13 @@ struct CallbackHelper<CInfoT, F, void(*)(CArgs...)> {
         "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)...);
+    using Impl = CallbackHelperImpl<R, CInfoT, F, CArgsTuple, std::make_index_sequence<NumCArgs - 2>>;
+    static R Call(CArgs... args) {
+        return Impl::Call(std::forward<CArgs>(args)...);
     }
     template <typename T>
-    static void Call(CArgs... args) {
-        Impl::template Call<T>(std::forward<CArgs>(args)...);
+    static R Call(CArgs... args) {
+        return Impl::template Call<T>(std::forward<CArgs>(args)...);
     }
 };
 
@@ -4526,6 +4778,7 @@ struct CallbackInfoHelper {
 // error: 'offsetof' within non-standard-layout type 'wgpu::XXX' is conditionally-supported
 #pragma GCC diagnostic ignored "-Winvalid-offsetof"
 #endif
+// NOLINTBEGIN(bugprone-invalid-enum-default-initialization)
 
 // AdapterPropertiesD3D implementation
 AdapterPropertiesD3D::AdapterPropertiesD3D()
@@ -4743,6 +4996,8 @@ static_assert(offsetof(ColorSpaceDawn, yCbCrRange) == offsetof(WGPUColorSpaceDaw
         "offsetof mismatch for ColorSpaceDawn::yCbCrRange");
 static_assert(offsetof(ColorSpaceDawn, yCbCrMatrix) == offsetof(WGPUColorSpaceDawn, yCbCrMatrix),
         "offsetof mismatch for ColorSpaceDawn::yCbCrMatrix");
+static_assert(offsetof(ColorSpaceDawn, hdrReferenceWhiteLuminance) == offsetof(WGPUColorSpaceDawn, hdrReferenceWhiteLuminance),
+        "offsetof mismatch for ColorSpaceDawn::hdrReferenceWhiteLuminance");
 
 // ColorTargetStateExpandResolveTextureDawn implementation
 ColorTargetStateExpandResolveTextureDawn::ColorTargetStateExpandResolveTextureDawn()
@@ -4897,16 +5152,38 @@ DawnCacheDeviceDescriptor::DawnCacheDeviceDescriptor()
 struct DawnCacheDeviceDescriptor::Init {
     ChainedStruct * const nextInChain;
     StringView isolationKey = {};
-    DawnLoadCacheDataFunction loadDataFunction = nullptr;
-    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)) {}
+    detail::DawnCacheDeviceDescriptor {
+        std::move(init.isolationKey),
+    } {}
+template <typename F, typename T>
+void DawnCacheDeviceDescriptor::SetDawnLoadCacheDataCallback(F callback, T userdata) {
+    static_assert(offsetof(DawnCacheDeviceDescriptor, dawnLoadCacheDataCallbackInfo) == offsetof(WGPUDawnCacheDeviceDescriptor, dawnLoadCacheDataCallbackInfo),
+                  "offsetof mismatch for DawnCacheDeviceDescriptor::dawnLoadCacheDataCallbackInfo");
+
+    assert(dawnLoadCacheDataCallbackInfo.callback == nullptr);
+    dawnLoadCacheDataCallbackInfo = detail::CallbackInfoHelper<WGPUDawnLoadCacheDataCallbackInfo, F>::Create(std::move(callback), userdata);
+}
+template <typename F>
+void DawnCacheDeviceDescriptor::SetDawnLoadCacheDataCallback(F callback) {
+    assert(dawnLoadCacheDataCallbackInfo.callback == nullptr);
+    dawnLoadCacheDataCallbackInfo = detail::CallbackInfoHelper<WGPUDawnLoadCacheDataCallbackInfo, F>::Create(std::move(callback));
+}
+template <typename F, typename T>
+void DawnCacheDeviceDescriptor::SetDawnStoreCacheDataCallback(F callback, T userdata) {
+    static_assert(offsetof(DawnCacheDeviceDescriptor, dawnStoreCacheDataCallbackInfo) == offsetof(WGPUDawnCacheDeviceDescriptor, dawnStoreCacheDataCallbackInfo),
+                  "offsetof mismatch for DawnCacheDeviceDescriptor::dawnStoreCacheDataCallbackInfo");
+
+    assert(dawnStoreCacheDataCallbackInfo.callback == nullptr);
+    dawnStoreCacheDataCallbackInfo = detail::CallbackInfoHelper<WGPUDawnStoreCacheDataCallbackInfo, F>::Create(std::move(callback), userdata);
+}
+template <typename F>
+void DawnCacheDeviceDescriptor::SetDawnStoreCacheDataCallback(F callback) {
+    assert(dawnStoreCacheDataCallbackInfo.callback == nullptr);
+    dawnStoreCacheDataCallbackInfo = detail::CallbackInfoHelper<WGPUDawnStoreCacheDataCallbackInfo, F>::Create(std::move(callback));
+}
 
 DawnCacheDeviceDescriptor::operator const WGPUDawnCacheDeviceDescriptor&() const noexcept {
     return *reinterpret_cast<const WGPUDawnCacheDeviceDescriptor*>(this);
@@ -4916,12 +5193,6 @@ static_assert(sizeof(DawnCacheDeviceDescriptor) == sizeof(WGPUDawnCacheDeviceDes
 static_assert(alignof(DawnCacheDeviceDescriptor) == alignof(WGPUDawnCacheDeviceDescriptor), "alignof mismatch for DawnCacheDeviceDescriptor");
 static_assert(offsetof(DawnCacheDeviceDescriptor, isolationKey) == offsetof(WGPUDawnCacheDeviceDescriptor, isolationKey),
         "offsetof mismatch for DawnCacheDeviceDescriptor::isolationKey");
-static_assert(offsetof(DawnCacheDeviceDescriptor, loadDataFunction) == offsetof(WGPUDawnCacheDeviceDescriptor, loadDataFunction),
-        "offsetof mismatch for DawnCacheDeviceDescriptor::loadDataFunction");
-static_assert(offsetof(DawnCacheDeviceDescriptor, storeDataFunction) == offsetof(WGPUDawnCacheDeviceDescriptor, storeDataFunction),
-        "offsetof mismatch for DawnCacheDeviceDescriptor::storeDataFunction");
-static_assert(offsetof(DawnCacheDeviceDescriptor, functionUserdata) == offsetof(WGPUDawnCacheDeviceDescriptor, functionUserdata),
-        "offsetof mismatch for DawnCacheDeviceDescriptor::functionUserdata");
 
 // DawnCompilationMessageUtf16 implementation
 DawnCompilationMessageUtf16::DawnCompilationMessageUtf16()
@@ -5828,30 +6099,6 @@ static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, signaledValueCou
 static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, signaledValues) == offsetof(WGPUSharedBufferMemoryBeginAccessDescriptor, signaledValues),
         "offsetof mismatch for SharedBufferMemoryBeginAccessDescriptor::signaledValues");
 
-// SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor implementation
-SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::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::operator const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor&() const noexcept {
-    return *reinterpret_cast<const WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor*>(this);
-}
-
-static_assert(sizeof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor) == sizeof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor), "sizeof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor");
-static_assert(alignof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor) == alignof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor), "alignof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor");
-static_assert(offsetof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, handle) == offsetof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, handle),
-        "offsetof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::handle");
-static_assert(offsetof(SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, size) == offsetof(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, size),
-        "offsetof mismatch for SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor::size");
-
 // SharedBufferMemoryEndAccessState implementation
 SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState() = default;
 SharedBufferMemoryEndAccessState::~SharedBufferMemoryEndAccessState() {
@@ -5917,6 +6164,30 @@ static_assert(offsetof(SharedBufferMemoryEndAccessState, signaledValueCount) ==
 static_assert(offsetof(SharedBufferMemoryEndAccessState, signaledValues) == offsetof(WGPUSharedBufferMemoryEndAccessState, signaledValues),
         "offsetof mismatch for SharedBufferMemoryEndAccessState::signaledValues");
 
+// SharedBufferMemoryFromWindowsHandleDescriptor implementation
+SharedBufferMemoryFromWindowsHandleDescriptor::SharedBufferMemoryFromWindowsHandleDescriptor()
+: ChainedStruct { nullptr, SType::SharedBufferMemoryFromWindowsHandleDescriptor } {}
+struct SharedBufferMemoryFromWindowsHandleDescriptor::Init {
+    ChainedStruct * const nextInChain;
+    void * handle;
+    uint64_t size;
+};
+SharedBufferMemoryFromWindowsHandleDescriptor::SharedBufferMemoryFromWindowsHandleDescriptor(SharedBufferMemoryFromWindowsHandleDescriptor::Init&& init) :
+    ChainedStruct { init.nextInChain, SType::SharedBufferMemoryFromWindowsHandleDescriptor },
+    handle(std::move(init.handle)),
+    size(std::move(init.size)) {}
+
+SharedBufferMemoryFromWindowsHandleDescriptor::operator const WGPUSharedBufferMemoryFromWindowsHandleDescriptor&() const noexcept {
+    return *reinterpret_cast<const WGPUSharedBufferMemoryFromWindowsHandleDescriptor*>(this);
+}
+
+static_assert(sizeof(SharedBufferMemoryFromWindowsHandleDescriptor) == sizeof(WGPUSharedBufferMemoryFromWindowsHandleDescriptor), "sizeof mismatch for SharedBufferMemoryFromWindowsHandleDescriptor");
+static_assert(alignof(SharedBufferMemoryFromWindowsHandleDescriptor) == alignof(WGPUSharedBufferMemoryFromWindowsHandleDescriptor), "alignof mismatch for SharedBufferMemoryFromWindowsHandleDescriptor");
+static_assert(offsetof(SharedBufferMemoryFromWindowsHandleDescriptor, handle) == offsetof(WGPUSharedBufferMemoryFromWindowsHandleDescriptor, handle),
+        "offsetof mismatch for SharedBufferMemoryFromWindowsHandleDescriptor::handle");
+static_assert(offsetof(SharedBufferMemoryFromWindowsHandleDescriptor, size) == offsetof(WGPUSharedBufferMemoryFromWindowsHandleDescriptor, size),
+        "offsetof mismatch for SharedBufferMemoryFromWindowsHandleDescriptor::size");
+
 // SharedBufferMemoryProperties implementation
 
 SharedBufferMemoryProperties::operator const WGPUSharedBufferMemoryProperties&() const noexcept {
@@ -8671,7 +8942,7 @@ static_assert(offsetof(RenderPipelineDescriptor, multisample) == offsetof(WGPURe
 static_assert(offsetof(RenderPipelineDescriptor, fragment) == offsetof(WGPURenderPipelineDescriptor, fragment),
         "offsetof mismatch for RenderPipelineDescriptor::fragment");
 
-
+// NOLINTEND(bugprone-invalid-enum-default-initialization)
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
@@ -9012,10 +9283,18 @@ Buffer Device::CreateErrorBuffer(BufferDescriptor const * descriptor) const {
     auto result = wgpuDeviceCreateErrorBuffer(Get(), reinterpret_cast<WGPUBufferDescriptor const *>(descriptor));
     return Buffer::Acquire(result);
 }
+ComputePipeline Device::CreateErrorComputePipeline(StringView label) const {
+    auto result = wgpuDeviceCreateErrorComputePipeline(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+    return ComputePipeline::Acquire(result);
+}
 ExternalTexture Device::CreateErrorExternalTexture() const {
     auto result = wgpuDeviceCreateErrorExternalTexture(Get());
     return ExternalTexture::Acquire(result);
 }
+RenderPipeline Device::CreateErrorRenderPipeline(StringView label) const {
+    auto result = wgpuDeviceCreateErrorRenderPipeline(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
+    return RenderPipeline::Acquire(result);
+}
 ShaderModule Device::CreateErrorShaderModule(ShaderModuleDescriptor const * descriptor, StringView errorMessage) const {
     auto result = wgpuDeviceCreateErrorShaderModule(Get(), reinterpret_cast<WGPUShaderModuleDescriptor const *>(descriptor), *reinterpret_cast<WGPUStringView const*>(&errorMessage));
     return ShaderModule::Acquire(result);
@@ -9433,12 +9712,12 @@ uint32_t ResourceTable::GetSize() const {
     auto result = wgpuResourceTableGetSize(Get());
     return result;
 }
-uint32_t ResourceTable::InsertBinding(BindingResource const * resource) const {
-    auto result = wgpuResourceTableInsertBinding(Get(), reinterpret_cast<WGPUBindingResource const *>(resource));
+uint32_t ResourceTable::Insert(BindingResource const * resource) const {
+    auto result = wgpuResourceTableInsert(Get(), reinterpret_cast<WGPUBindingResource const *>(resource));
     return result;
 }
-ConvertibleStatus ResourceTable::RemoveBinding(uint32_t slot) const {
-    auto result = wgpuResourceTableRemoveBinding(Get(), slot);
+ConvertibleStatus ResourceTable::Remove(uint32_t slot) const {
+    auto result = wgpuResourceTableRemove(Get(), slot);
     return static_cast<Status>(result);
 }
 void ResourceTable::SetLabel(StringView label) const {
@@ -9733,18 +10012,12 @@ uint32_t Texture::GetWidth() const {
     auto result = wgpuTextureGetWidth(Get());
     return result;
 }
-void Texture::Pin(TextureUsage usage) const {
-    wgpuTexturePin(Get(), static_cast<WGPUTextureUsage>(usage));
-}
 void Texture::SetLabel(StringView label) const {
     wgpuTextureSetLabel(Get(), *reinterpret_cast<WGPUStringView const*>(&label));
 }
 void Texture::SetOwnershipForMemoryDump(uint64_t ownerGuid) const {
     wgpuTextureSetOwnershipForMemoryDump(Get(), ownerGuid);
 }
-void Texture::Unpin() const {
-    wgpuTextureUnpin(Get());
-}
 
 
 void Texture::WGPUAddRef(WGPUTexture handle) {
@@ -9995,22 +10268,22 @@ static_assert(alignof(RenderPassEncoder) == alignof(WGPURenderPassEncoder), "ali
 
 
 // Free Functions
-static inline Instance CreateInstance(InstanceDescriptor const * descriptor = nullptr) {
+inline Instance CreateInstance(InstanceDescriptor const * descriptor = nullptr) {
     auto result = wgpuCreateInstance(reinterpret_cast<WGPUInstanceDescriptor const *>(descriptor));
     return Instance::Acquire(result);
 }
-static inline void GetInstanceFeatures(SupportedInstanceFeatures * features) {
+inline void GetInstanceFeatures(SupportedInstanceFeatures * features) {
     wgpuGetInstanceFeatures(reinterpret_cast<WGPUSupportedInstanceFeatures *>(features));
 }
-static inline Status GetInstanceLimits(InstanceLimits * limits) {
+inline Status GetInstanceLimits(InstanceLimits * limits) {
     auto result = wgpuGetInstanceLimits(reinterpret_cast<WGPUInstanceLimits *>(limits));
     return static_cast<Status>(result);
 }
-static inline Bool HasInstanceFeature(InstanceFeatureName feature) {
+inline Bool HasInstanceFeature(InstanceFeatureName feature) {
     auto result = wgpuHasInstanceFeature(static_cast<WGPUInstanceFeatureName>(feature));
     return result;
 }
-static inline Proc GetProcAddress(StringView procName) {
+inline Proc GetProcAddress(StringView procName) {
     auto result = wgpuGetProcAddress(*reinterpret_cast<WGPUStringView const*>(&procName));
     return reinterpret_cast<Proc>(result);
 }