diff --git a/src/TUnit.Mocks.SourceGenerator/Extensions/MethodSymbolExtensions.cs b/src/TUnit.Mocks.SourceGenerator/Extensions/MethodSymbolExtensions.cs
index 1ef284ba65..e5c7212a04 100644
--- a/src/TUnit.Mocks.SourceGenerator/Extensions/MethodSymbolExtensions.cs
+++ b/src/TUnit.Mocks.SourceGenerator/Extensions/MethodSymbolExtensions.cs
@@ -36,7 +36,9 @@ public static string GetGenericConstraints(this ITypeParameterSymbol typeParam)
 
         if (typeParam.HasReferenceTypeConstraint)
             constraints.Add("class");
-        if (typeParam.HasValueTypeConstraint)
+        // Roslyn reports HasValueTypeConstraint for 'unmanaged' too, but C# forbids
+        // combining 'struct' with 'unmanaged' (CS0449) — emit only 'unmanaged' (#6471)
+        if (typeParam.HasValueTypeConstraint && !typeParam.HasUnmanagedTypeConstraint)
             constraints.Add("struct");
         if (typeParam.HasUnmanagedTypeConstraint)
             constraints.Add("unmanaged");
diff --git a/tests/TUnit.Mocks.SourceGenerator.Tests/MockGeneratorTests.cs b/tests/TUnit.Mocks.SourceGenerator.Tests/MockGeneratorTests.cs
index 087607c788..2315cb7060 100644
--- a/tests/TUnit.Mocks.SourceGenerator.Tests/MockGeneratorTests.cs
+++ b/tests/TUnit.Mocks.SourceGenerator.Tests/MockGeneratorTests.cs
@@ -492,6 +492,73 @@ void M()
         return VerifyGeneratorOutput(source);
     }
 
+    [Test]
+    public Task Interface_With_Unmanaged_Constrained_Type_Parameter()
+    {
+        // #6471: 'unmanaged' also sets HasValueTypeConstraint, so the generator emitted
+        // 'where T : struct, unmanaged' which is invalid C# (CS0449)
+        var source = """
+            using System;
+            using TUnit.Mocks;
+
+            public interface ISnapshotSource<T> where T : unmanaged
+            {
+                void Fill(ref T snapshot);
+            }
+
+            public interface IConstrainedSource<T> where T : unmanaged, IDisposable
+            {
+                T Get();
+            }
+
+            public class TestUsage
+            {
+                void M()
+                {
+                    var mock = Mock.Of<ISnapshotSource<int>>();
+                    var mock2 = Mock.Of<IConstrainedSource<System.Threading.CancellationTokenRegistration>>();
+                }
+            }
+            """;
+
+        return VerifyGeneratorOutput(source);
+    }
+
+    [Test]
+    public void Interface_With_Unmanaged_Constrained_Type_Parameter_Compiles()
+    {
+        var source = """
+            using System;
+            using TUnit.Mocks;
+
+            public interface ISnapshotSource<T> where T : unmanaged
+            {
+                void Fill(ref T snapshot);
+            }
+
+            public class TestUsage
+            {
+                void M()
+                {
+                    var mock = Mock.Of<ISnapshotSource<int>>();
+                }
+            }
+            """;
+
+        var errors = GetGeneratedCompilationErrors(source);
+
+        // CS0449: invalid 'struct, unmanaged' combination; CS8377: cascade when T no
+        // longer satisfies the interface's 'unmanaged' constraint (#6471)
+        foreach (var id in (string[])["CS0449", "CS8377"])
+        {
+            var match = errors.FirstOrDefault(e => string.Equals(e.Id, id, StringComparison.Ordinal));
+            if (match is not null)
+            {
+                throw new InvalidOperationException($"Generated code produced {id}: {match}");
+            }
+        }
+    }
+
     [Test]
     public Task Interface_With_Overloaded_Methods()
     {
diff --git a/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Generic_Method_Constraints_On_Explicit_Impl.verified.txt b/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Generic_Method_Constraints_On_Explicit_Impl.verified.txt
index 47307014a3..2318debc6d 100644
--- a/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Generic_Method_Constraints_On_Explicit_Impl.verified.txt
+++ b/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Generic_Method_Constraints_On_Explicit_Impl.verified.txt
@@ -50,7 +50,7 @@ file sealed class IConstrainedMockImpl : global::IConstrained, global::TUnit.Moc
         return _engine.HandleCallWithReturn<T>(1, "GetNew", global::System.Array.Empty<object?>(), default!, global::TUnit.Mocks.TypeArguments.Of<T>.Value);
     }
 
-    public T GetUnmanaged<T>() where T : struct, unmanaged
+    public T GetUnmanaged<T>() where T : unmanaged
     {
         return _engine.HandleCallWithReturn<T>(2, "GetUnmanaged", global::System.Array.Empty<object?>(), default, global::TUnit.Mocks.TypeArguments.Of<T>.Value);
     }
@@ -133,7 +133,7 @@ public static class IConstrained_MockMemberExtensions
         return new global::TUnit.Mocks.MockMethodCall<T>(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 1, "GetNew", matchers, global::TUnit.Mocks.TypeArguments.Of<T>.Value);
     }
 
-    public static global::TUnit.Mocks.MockMethodCall<T> GetUnmanaged<T>(this global::TUnit.Mocks.Mock<global::IConstrained> mock) where T : struct, unmanaged
+    public static global::TUnit.Mocks.MockMethodCall<T> GetUnmanaged<T>(this global::TUnit.Mocks.Mock<global::IConstrained> mock) where T : unmanaged
     {
         var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
         return new global::TUnit.Mocks.MockMethodCall<T>(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 2, "GetUnmanaged", matchers, global::TUnit.Mocks.TypeArguments.Of<T>.Value);
diff --git a/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Unmanaged_Constrained_Type_Parameter.verified.txt b/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Unmanaged_Constrained_Type_Parameter.verified.txt
new file mode 100644
index 0000000000..a3ce482315
--- /dev/null
+++ b/tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Interface_With_Unmanaged_Constrained_Type_Parameter.verified.txt
@@ -0,0 +1,404 @@
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+public sealed class IConstrainedSource_T_Mock<T> : global::TUnit.Mocks.Mock<global::IConstrainedSource<T>>, global::IConstrainedSource<T> where T : unmanaged, global::System.IDisposable
+{
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal IConstrainedSource_T_Mock(global::IConstrainedSource<T> mockObject, global::TUnit.Mocks.MockEngine<global::IConstrainedSource<T>> engine)
+        : base(mockObject, engine) { }
+
+    T global::IConstrainedSource<T>.Get() => Object.Get();
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+file sealed class IConstrainedSource_T_MockImpl<T> : global::IConstrainedSource<T>, global::TUnit.Mocks.IRaisable, global::TUnit.Mocks.IMockObject where T : unmanaged, global::System.IDisposable
+{
+    private readonly global::TUnit.Mocks.MockEngine<global::IConstrainedSource<T>> _engine;
+
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    global::TUnit.Mocks.IMock? global::TUnit.Mocks.IMockObject.MockWrapper { get; set; }
+
+    internal IConstrainedSource_T_MockImpl(global::TUnit.Mocks.MockEngine<global::IConstrainedSource<T>> engine)
+    {
+        _engine = engine;
+    }
+
+    public T Get()
+    {
+        return _engine.HandleCallWithReturn<T>(0, "Get", global::System.Array.Empty<object?>(), default);
+    }
+
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    public void RaiseEvent(string eventName, object? args)
+    {
+        throw new global::System.InvalidOperationException($"No event named '{eventName}' exists on this mock.");
+    }
+}
+
+internal static class IConstrainedSource_T_MockFactory
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    internal static void Register()
+    {
+        global::TUnit.Mocks.MockRegistry.RegisterOpenGenericFactory(
+            typeof(global::IConstrainedSource<>),
+            typeof(IConstrainedSource_T_MockImpl<>),
+            typeof(IConstrainedSource_T_Mock<>));
+    }
+
+    internal static global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> CreateAutoMock<T>(global::TUnit.Mocks.MockBehavior behavior) where T : unmanaged, global::System.IDisposable
+    {
+        var engine = new global::TUnit.Mocks.MockEngine<global::IConstrainedSource<T>>(behavior);
+        var impl = new IConstrainedSource_T_MockImpl<T>(engine);
+        engine.Raisable = impl;
+        var mock = new IConstrainedSource_T_Mock<T>(impl, engine);
+        return mock;
+    }
+
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+public static class IConstrainedSource_T__MockMemberExtensions
+{
+    public static global::TUnit.Mocks.MockMethodCall<T> Get<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+    {
+        var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
+        return new global::TUnit.Mocks.MockMethodCall<T>(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 0, "Get", matchers);
+    }
+
+    #if NET9_0_OR_GREATER
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void Reset<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.Reset(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void VerifyAll<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.VerifyAll(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void VerifyNoOtherCalls<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.VerifyNoOtherCalls(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void SetupAllProperties<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.SetupAllProperties(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static global::TUnit.Mocks.Diagnostics.MockDiagnostics GetDiagnostics<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.GetDiagnostics(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void SetState<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock, string? stateName) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.SetState(mock, stateName);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void InState<T>(this global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock, string stateName, global::System.Action<global::TUnit.Mocks.Mock<global::IConstrainedSource<T>>> configure) where T : unmanaged, global::System.IDisposable
+        => global::TUnit.Mocks.Mock.InState(mock, stateName, configure);
+
+    extension<T>(global::TUnit.Mocks.Mock<global::IConstrainedSource<T>> mock) where T : unmanaged, global::System.IDisposable
+    {
+        public global::System.Collections.Generic.IReadOnlyList<global::TUnit.Mocks.Verification.CallRecord> Invocations => global::TUnit.Mocks.Mock.Invocations(mock);
+
+        public global::TUnit.Mocks.MockBehavior Behavior => global::TUnit.Mocks.Mock.Behavior(mock);
+
+        public global::TUnit.Mocks.IDefaultValueProvider? DefaultValueProvider
+        {
+            get => global::TUnit.Mocks.Mock.GetDefaultValueProvider(mock);
+            set => global::TUnit.Mocks.Mock.SetDefaultValueProvider(mock, value);
+        }
+    }
+    #endif
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+namespace TUnit.Mocks
+{
+    public static class IConstrainedSource_T__MockStaticExtension
+    {
+        extension<T>(global::IConstrainedSource<T> _) where T : unmanaged, global::System.IDisposable
+        {
+            public static global::IConstrainedSource_T_Mock<T> Mock()
+            {
+                return (global::IConstrainedSource_T_Mock<T>)global::IConstrainedSource_T_MockFactory.CreateAutoMock<T>(global::TUnit.Mocks.Mock.DefaultBehavior);
+            }
+
+            public static global::IConstrainedSource_T_Mock<T> Mock(global::TUnit.Mocks.MockBehavior behavior)
+            {
+                return (global::IConstrainedSource_T_Mock<T>)global::IConstrainedSource_T_MockFactory.CreateAutoMock<T>(behavior);
+            }
+        }
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+public sealed class ISnapshotSource_T_Mock<T> : global::TUnit.Mocks.Mock<global::ISnapshotSource<T>>, global::ISnapshotSource<T> where T : unmanaged
+{
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    internal ISnapshotSource_T_Mock(global::ISnapshotSource<T> mockObject, global::TUnit.Mocks.MockEngine<global::ISnapshotSource<T>> engine)
+        : base(mockObject, engine) { }
+
+    void global::ISnapshotSource<T>.Fill(ref T snapshot)
+    {
+        Object.Fill(ref snapshot);
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+file sealed class ISnapshotSource_T_MockImpl<T> : global::ISnapshotSource<T>, global::TUnit.Mocks.IRaisable, global::TUnit.Mocks.IMockObject where T : unmanaged
+{
+    private readonly global::TUnit.Mocks.MockEngine<global::ISnapshotSource<T>> _engine;
+
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    global::TUnit.Mocks.IMock? global::TUnit.Mocks.IMockObject.MockWrapper { get; set; }
+
+    internal ISnapshotSource_T_MockImpl(global::TUnit.Mocks.MockEngine<global::ISnapshotSource<T>> engine)
+    {
+        _engine = engine;
+    }
+
+    public void Fill(ref T snapshot)
+    {
+        _engine.HandleCall<T>(0, "Fill", snapshot);
+        var __outRef = global::TUnit.Mocks.Setup.OutRefContext.Consume();
+        if (__outRef is not null)
+        {
+            if (__outRef.TryGetValue(0, out var __v0)) snapshot = (T)__v0!;
+        }
+    }
+
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    public void RaiseEvent(string eventName, object? args)
+    {
+        throw new global::System.InvalidOperationException($"No event named '{eventName}' exists on this mock.");
+    }
+}
+
+internal static class ISnapshotSource_T_MockFactory
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    internal static void Register()
+    {
+        global::TUnit.Mocks.MockRegistry.RegisterOpenGenericFactory(
+            typeof(global::ISnapshotSource<>),
+            typeof(ISnapshotSource_T_MockImpl<>),
+            typeof(ISnapshotSource_T_Mock<>));
+    }
+
+    internal static global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> CreateAutoMock<T>(global::TUnit.Mocks.MockBehavior behavior) where T : unmanaged
+    {
+        var engine = new global::TUnit.Mocks.MockEngine<global::ISnapshotSource<T>>(behavior);
+        var impl = new ISnapshotSource_T_MockImpl<T>(engine);
+        engine.Raisable = impl;
+        var mock = new ISnapshotSource_T_Mock<T>(impl, engine);
+        return mock;
+    }
+
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+public static class ISnapshotSource_T__MockMemberExtensions
+{
+    public static ISnapshotSource_T__Fill_M0_MockCall<T> Fill<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock, global::TUnit.Mocks.Arguments.Arg<T> snapshot) where T : unmanaged
+    {
+        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { snapshot.Matcher };
+        return new ISnapshotSource_T__Fill_M0_MockCall<T>(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 0, "Fill", matchers);
+    }
+
+    #if NET9_0_OR_GREATER
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void Reset<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock) where T : unmanaged
+        => global::TUnit.Mocks.Mock.Reset(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void VerifyAll<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock) where T : unmanaged
+        => global::TUnit.Mocks.Mock.VerifyAll(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void VerifyNoOtherCalls<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock) where T : unmanaged
+        => global::TUnit.Mocks.Mock.VerifyNoOtherCalls(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void SetupAllProperties<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock) where T : unmanaged
+        => global::TUnit.Mocks.Mock.SetupAllProperties(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static global::TUnit.Mocks.Diagnostics.MockDiagnostics GetDiagnostics<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock) where T : unmanaged
+        => global::TUnit.Mocks.Mock.GetDiagnostics(mock);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void SetState<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock, string? stateName) where T : unmanaged
+        => global::TUnit.Mocks.Mock.SetState(mock, stateName);
+
+    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
+    public static void InState<T>(this global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock, string stateName, global::System.Action<global::TUnit.Mocks.Mock<global::ISnapshotSource<T>>> configure) where T : unmanaged
+        => global::TUnit.Mocks.Mock.InState(mock, stateName, configure);
+
+    extension<T>(global::TUnit.Mocks.Mock<global::ISnapshotSource<T>> mock) where T : unmanaged
+    {
+        public global::System.Collections.Generic.IReadOnlyList<global::TUnit.Mocks.Verification.CallRecord> Invocations => global::TUnit.Mocks.Mock.Invocations(mock);
+
+        public global::TUnit.Mocks.MockBehavior Behavior => global::TUnit.Mocks.Mock.Behavior(mock);
+
+        public global::TUnit.Mocks.IDefaultValueProvider? DefaultValueProvider
+        {
+            get => global::TUnit.Mocks.Mock.GetDefaultValueProvider(mock);
+            set => global::TUnit.Mocks.Mock.SetDefaultValueProvider(mock, value);
+        }
+    }
+    #endif
+}
+
+[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+public sealed class ISnapshotSource_T__Fill_M0_MockCall<T> : global::TUnit.Mocks.Verification.ICallVerification where T : unmanaged
+{
+    private readonly global::TUnit.Mocks.IMockEngineAccess _engine;
+    private readonly int _memberId;
+    private readonly string _memberName;
+    private readonly global::TUnit.Mocks.Arguments.IArgumentMatcher[] _matchers;
+    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder? _builder;
+
+    internal ISnapshotSource_T__Fill_M0_MockCall(global::TUnit.Mocks.IMockEngineAccess engine, int memberId, string memberName, global::TUnit.Mocks.Arguments.IArgumentMatcher[] matchers)
+    {
+        _engine = engine;
+        _memberId = memberId;
+        _memberName = memberName;
+        _matchers = matchers;
+        _ = EnsureSetup();
+    }
+
+    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder EnsureSetup()
+    {
+        var existing = global::System.Threading.Volatile.Read(ref _builder);
+        if (existing is not null) return existing;
+        return EnsureSetupSlow();
+    }
+
+    [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
+    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder EnsureSetupSlow()
+    {
+        var setup = new global::TUnit.Mocks.Setup.MethodSetup(_memberId, _matchers, _memberName);
+        var fresh = new global::TUnit.Mocks.Setup.VoidMethodSetupBuilder(setup);
+        var prev = global::System.Threading.Interlocked.CompareExchange(ref _builder, fresh, null);
+        if (prev is not null) return prev;
+        // AddSetup runs only on the CAS winner. Setup is sequential in practice,
+        // so a concurrent loser observing the builder before registration is benign.
+        _engine.AddSetup(setup);
+        return fresh;
+    }
+
+    /// <inheritdoc />
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Returns() { EnsureSetup().Returns(); return this; }
+    /// <inheritdoc />
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Throws<TException>() where TException : global::System.Exception, new() { EnsureSetup().Throws<TException>(); return this; }
+    /// <inheritdoc />
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Throws(global::System.Exception exception) { EnsureSetup().Throws(exception); return this; }
+    /// <inheritdoc />
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Callback(global::System.Action callback) { EnsureSetup().Callback(callback); return this; }
+    /// <inheritdoc />
+    public ISnapshotSource_T__Fill_M0_MockCall<T> TransitionsTo(string stateName) { EnsureSetup().TransitionsTo(stateName); return this; }
+    /// <inheritdoc />
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Then() { EnsureSetup().Then(); return this; }
+
+    /// <summary>Execute a typed callback using the actual method parameters.</summary>
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Callback(global::System.Action<T> callback)
+    {
+        EnsureSetup().Callback(callback);
+        return this;
+    }
+
+    /// <summary>Configure a typed computed exception using the actual method parameters.</summary>
+    public ISnapshotSource_T__Fill_M0_MockCall<T> Throws(global::System.Func<T, global::System.Exception> exceptionFactory)
+    {
+        EnsureSetup().Throws(args => exceptionFactory((T)args[0]!));
+        return this;
+    }
+
+    /// <summary>Sets the 'snapshot' ref parameter to the specified value when this setup matches.</summary>
+    public ISnapshotSource_T__Fill_M0_MockCall<T> SetsRefSnapshot(T snapshot) { EnsureSetup().SetsOutParameter(0, snapshot); return this; }
+
+    // ICallVerification
+    /// <inheritdoc />
+    public void WasCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled();
+    /// <inheritdoc />
+    public void WasCalled(global::TUnit.Mocks.Times times) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times);
+    /// <inheritdoc />
+    public void WasCalled(global::TUnit.Mocks.Times times, string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times, message);
+    /// <inheritdoc />
+    public void WasCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(message);
+    /// <inheritdoc />
+    public void WasNeverCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled();
+    /// <inheritdoc />
+    public void WasNeverCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled(message);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+namespace TUnit.Mocks
+{
+    public static class ISnapshotSource_T__MockStaticExtension
+    {
+        extension<T>(global::ISnapshotSource<T> _) where T : unmanaged
+        {
+            public static global::ISnapshotSource_T_Mock<T> Mock()
+            {
+                return (global::ISnapshotSource_T_Mock<T>)global::ISnapshotSource_T_MockFactory.CreateAutoMock<T>(global::TUnit.Mocks.Mock.DefaultBehavior);
+            }
+
+            public static global::ISnapshotSource_T_Mock<T> Mock(global::TUnit.Mocks.MockBehavior behavior)
+            {
+                return (global::ISnapshotSource_T_Mock<T>)global::ISnapshotSource_T_MockFactory.CreateAutoMock<T>(behavior);
+            }
+        }
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+#nullable enable
+
+namespace TUnit.Mocks.Generated;
\ No newline at end of file