diff --git a/EasySourceGenerators.Abstractions/FluentApiStarters/Generate.cs b/EasySourceGenerators.Abstractions/FluentApiStarters/Generate.cs
index 1b42ecd..0d3265a 100644
--- a/EasySourceGenerators.Abstractions/FluentApiStarters/Generate.cs
+++ b/EasySourceGenerators.Abstractions/FluentApiStarters/Generate.cs
@@ -1,4 +1,5 @@
-using JetBrains.Annotations;
+using EasySourceGenerators.Abstractions.Method;
+using JetBrains.Annotations;
 
 namespace EasySourceGenerators.Abstractions;
 
diff --git a/EasySourceGenerators.Abstractions/FluentApiStarters/IGeneratorsFactory.cs b/EasySourceGenerators.Abstractions/FluentApiStarters/IGeneratorsFactory.cs
index b0c4777..2b882b1 100644
--- a/EasySourceGenerators.Abstractions/FluentApiStarters/IGeneratorsFactory.cs
+++ b/EasySourceGenerators.Abstractions/FluentApiStarters/IGeneratorsFactory.cs
@@ -1,6 +1,9 @@
-namespace EasySourceGenerators.Abstractions;
+using EasySourceGenerators.Abstractions.Method;
+
+namespace EasySourceGenerators.Abstractions;
 
 public interface IGeneratorsFactory
 {
     IMethodBodyBuilderStage1 StartFluentApiBuilderForBody();
+    IMethodBuilderStage1 StartFluentApiBuilderForMethod();
 }
\ No newline at end of file
diff --git a/EasySourceGenerators.Abstractions/Method/IMethodBuilderStage1.cs b/EasySourceGenerators.Abstractions/Method/IMethodBuilderStage1.cs
index 3f86848..9987397 100644
--- a/EasySourceGenerators.Abstractions/Method/IMethodBuilderStage1.cs
+++ b/EasySourceGenerators.Abstractions/Method/IMethodBuilderStage1.cs
@@ -30,13 +30,13 @@ public interface IMethodBuilderStage3ReturningVoid
 
 public interface IMethodBuilderStage3<TReturnType>
 {
-    IMethodBuilderStage4NoParam WithNoParameters();
+    IMethodBuilderStage4NoParam<TReturnType> WithNoParameters();
     
-    IMethodBuilderStage4<TParam1> WithParameter<TParam1>();
-    IMethodBuilderStage4 WithParameter(Type param1);
-    IMethodBuilderStage4 WithParameter(string param1);
-    IMethodBuilderStage4 WithParameter(Func<Type> param1Factory);
-    IMethodBuilderStage4 WithParameter(Func<string> param1Factory);
+    IMethodBuilderStage4<TParam1, TReturnType> WithParameter<TParam1>();
+    IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Type param1);
+    IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(string param1);
+    IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Func<Type> param1Factory);
+    IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Func<string> param1Factory);
 }
 
 public interface IMethodBuilderStage3WithSomeReturnType
@@ -52,5 +52,52 @@ public interface IMethodBuilderStage3WithSomeReturnType
 
 public interface IMethodBuilderStage4ReturnVoidNoParam
 {
-    
+    IMethodBodyGenerator UseProvidedBody(Action body);
+}
+
+public interface IMethodBuilderStage4ReturnVoid<TParam1>
+{
+    IMethodBodyGenerator UseProvidedBody(Action<TParam1> body);
+}
+
+public interface IMethodBuilderStage4ReturnVoid
+{
+    IMethodBodyGenerator UseProvidedBody(Action<object> body);
+}
+
+public interface IMethodBuilderStage4NoParam<TReturnType>
+{
+    IMethodBodyGenerator UseProvidedBody(Func<TReturnType> body);
+    IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory);
+}
+
+public interface IMethodBuilderStage4<TParam1, TReturnType>
+{
+    IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body);
+    IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory);
+    IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> BodyWithSwitchStatement();
+}
+
+public interface IMethodBuilderStage4WithSomeParam<TReturnType>
+{
+    IMethodBodyGenerator UseProvidedBody(Func<object, TReturnType> body);
+    IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory);
+}
+
+public interface IMethodBuilderStage4WithSomeReturnTypeNoParam
+{
+    IMethodBodyGenerator UseProvidedBody(Func<object> body);
+    IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory);
+}
+
+public interface IMethodBuilderStage4WithSomeReturnType<TParam1>
+{
+    IMethodBodyGenerator UseProvidedBody(Func<TParam1, object> body);
+    IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory);
+}
+
+public interface IMethodBuilderStage4WithSomeReturnTypeWithSomeParam
+{
+    IMethodBodyGenerator UseProvidedBody(Func<object, object> body);
+    IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory);
 }
\ No newline at end of file
diff --git a/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyBuilder.cs b/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyBuilder.cs
index c01799b..a2962f9 100644
--- a/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyBuilder.cs
+++ b/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyBuilder.cs
@@ -2,7 +2,7 @@
 
 // ReSharper disable TypeParameterCanBeVariant - not available for every overload, so not used for consistency
 
-public interface IMethodBodyBuilderStage1
+public interface IMethodBodyBuilderStage1 : IMethodBodyBuilder
 {
     IMethodBodyBuilderStage2 ForMethod();
 }
@@ -41,7 +41,7 @@ public interface IMethodBodyBuilderStage4ReturnVoid<TParam1>
     IMethodBodyGenerator UseProvidedBody(Action<TParam1> body);
 }
 
-public interface IMethodBodyBuilderStage4<TParam1, in TReturnType>
+public interface IMethodBodyBuilderStage4<TParam1, TReturnType>
 {
     IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body);
     IMethodBodyGenerator BodyRetuningConstant(Func<TReturnType> constantValueFactory);
diff --git a/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGenerator.cs b/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGenerator.cs
index 0b97ea0..151d6ee 100644
--- a/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGenerator.cs
+++ b/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGenerator.cs
@@ -1,3 +1,34 @@
 namespace EasySourceGenerators.Abstractions;
 
-public interface IMethodBodyGenerator;
\ No newline at end of file
+public interface IMethodBodyGenerator;
+
+public interface IMethodBodyGeneratorWithNoParameter : IMethodBodyGenerator;
+
+public interface IMethodBodyGenerator<TReturnType> : IMethodBodyGenerator
+{
+    IMethodBodyGeneratorWithNoParameter BodyReturningConstantValue(Func<object> body);
+}
+
+public interface IMethodBodyGenerator<TArg1, TReturnType> : IMethodBodyGenerator
+{
+    IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> GenerateSwitchBody();
+}
+
+public interface IMethodBodyGeneratorStage0
+{
+    IMethodBodyGeneratorWithNoParameter CreateImplementation();
+    IMethodBodyGenerator<TReturnType> CreateImplementation<TReturnType>();
+    IMethodBodyGenerator<TArg1, TReturnType> CreateImplementation<TArg1, TReturnType>();
+    IMethodBodyBuilder ForMethod();
+}
+
+public interface IMethodBodyBuilder
+{
+    IMethodBodyBuilder<TArg1> WithParameter<TArg1>();
+    IMethodBodyGenerator<TReturnType> WithReturnType<TReturnType>();
+}
+
+public interface IMethodBodyBuilder<TArg1>
+{
+    IMethodBodyGenerator<TArg1, TReturnType> WithReturnType<TReturnType>();
+}
\ No newline at end of file
diff --git a/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGeneratorSwitchBody.cs b/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGeneratorSwitchBody.cs
index d669ab1..a4de829 100644
--- a/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGeneratorSwitchBody.cs
+++ b/EasySourceGenerators.Abstractions/MethodBody/IMethodBodyGeneratorSwitchBody.cs
@@ -1,33 +1,30 @@
 namespace EasySourceGenerators.Abstractions;
 
-public interface IMethodBodyGeneratorSwitchBody<TParam1, in TReturnType>
+// ReSharper disable TypeParameterCanBeVariant - variance removed for simplicity
+
+public interface IMethodBodyGeneratorSwitchBody<TParam1, TReturnType>
 {
-    IMethodBodyGeneratorSwitchBodyCase<TParam1, TReturnType> ForCases(params TParam1[] cases);
+    IMethodBodyGeneratorSwitchBodyCase<TParam1, TReturnType> ForCases(params object[] cases);
     IMethodBodyGeneratorSwitchBodyDefaultCase<TParam1, TReturnType> ForDefaultCase();
 }
 
-public interface IMethodBodyGeneratorSwitchBodyCase<out TParam1, in TReturnType>
+public interface IMethodBodyGeneratorSwitchBodyCase<TParam1, TReturnType>
 {
     /// <summary>
     /// Specific case(s) will use the body provided.
     /// </summary>
     /// <param name="body">During code generation this body will be emitted.</param>
-    IMethodBodyGeneratorSwitchBodyCaseStage2<TParam1, TReturnType> UseProvidedBody(Func<TParam1, TReturnType> body);
+    IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> UseProvidedBody(Func<TParam1, TReturnType> body);
     
     /// <summary>
     /// Specify case(s) will return a constant value.
     /// </summary>
     /// <param name="constantValueFactory">During code generation, this delegate will be run to calculate the constant value.
     /// The delegate will not be used in the generated code. Only the value it produces after it's executed during code generation.</param>
-    IMethodBodyGeneratorSwitchBodyCaseStage2<TParam1, TReturnType> ReturnConstantValue(Func<TParam1, TReturnType> constantValueFactory);
-}
-
-public interface IMethodBodyGeneratorSwitchBodyCaseStage2<out TParam1, in TReturnType>
-{
-    IMethodBodyGeneratorSwitchBodyDefaultCase<TParam1, TReturnType> ForDefaultCase();
+    IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> ReturnConstantValue(Func<TParam1, TReturnType> constantValueFactory);
 }
 
-public interface IMethodBodyGeneratorSwitchBodyDefaultCase<out TParam1, in TReturnType> : IMethodBodyGenerator
+public interface IMethodBodyGeneratorSwitchBodyDefaultCase<TParam1, TReturnType> : IMethodBodyGenerator
 {
     IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body);
     IMethodBodyGenerator ReturnConstantValue(Func<TParam1, TReturnType> constantValueFactory);
diff --git a/EasySourceGenerators.Abstractions/Mocks.cs b/EasySourceGenerators.Abstractions/Mocks.cs
index 764ed8c..87606b1 100644
--- a/EasySourceGenerators.Abstractions/Mocks.cs
+++ b/EasySourceGenerators.Abstractions/Mocks.cs
@@ -1,7 +1,13 @@
-namespace EasySourceGenerators.Abstractions;
+using EasySourceGenerators.Abstractions.Method;
+
+namespace EasySourceGenerators.Abstractions;
 
 public class MockGeneratorsFactory : IGeneratorsFactory
 {
+    public IMethodBodyBuilderStage1 StartFluentApiBuilderForBody() => new MockMethodBodyBuilderStage1();
+
+    public IMethodBuilderStage1 StartFluentApiBuilderForMethod() => new MockMethodBuilderStage1();
+
     public IMethodBodyBuilder ForMethod() => new MockMethodBodyBuilder();
 
     public IMethodBodyGenerator<TReturnType> CreateImplementation<TReturnType>() => new MockMethodImplementationGenerator<TReturnType>();
@@ -10,11 +16,64 @@ public IMethodBodyGenerator<TArg1, TReturnType> CreateImplementation<TArg1, TRet
         new MockMethodImplementationGenerator<TArg1, TReturnType>();
 }
 
+public class MockMethodBodyBuilderStage1 : IMethodBodyBuilderStage1
+{
+    public IMethodBodyBuilderStage2 ForMethod() => new MockMethodBodyBuilderStage2();
+    public IMethodBodyBuilder<TArg1> WithParameter<TArg1>() => new MockMethodBodyBuilder<TArg1>();
+    public IMethodBodyGenerator<TReturnType> WithReturnType<TReturnType>() => new MockMethodImplementationGenerator<TReturnType>();
+}
+
+public class MockMethodBodyBuilderStage2 : IMethodBodyBuilderStage2
+{
+    public IMethodBodyBuilderStage3ReturnVoid WithVoidReturnType() => new MockMethodBodyBuilderStage3ReturnVoid();
+    public IMethodBodyBuilderStage3<TReturnType> WithReturnType<TReturnType>() => new MockMethodBodyBuilderStage3<TReturnType>();
+}
+
+public class MockMethodBodyBuilderStage3ReturnVoid : IMethodBodyBuilderStage3ReturnVoid
+{
+    public IMethodBodyBuilderStage4ReturnVoidNoArg WithNoParameters() => new MockMethodBodyBuilderStage4ReturnVoidNoArg();
+    public IMethodBodyBuilderStage4ReturnVoid<TParam1> WithOneParameter<TParam1>() => new MockMethodBodyBuilderStage4ReturnVoid<TParam1>();
+}
+
+public class MockMethodBodyBuilderStage3<TReturnType> : IMethodBodyBuilderStage3<TReturnType>
+{
+    public IMethodBodyBuilderStage4NoArg<TReturnType> WithNoParameters() => new MockMethodBodyBuilderStage4NoArg<TReturnType>();
+    public IMethodBodyBuilderStage4<TParam1, TReturnType> WithOneParameter<TParam1>() => new MockMethodBodyBuilderStage4<TParam1, TReturnType>();
+}
+
+public class MockMethodBodyBuilderStage4ReturnVoidNoArg : IMethodBodyBuilderStage4ReturnVoidNoArg
+{
+    public IMethodBodyGenerator UseProvidedBody(Action body) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBodyBuilderStage4ReturnVoid<TParam1> : IMethodBodyBuilderStage4ReturnVoid<TParam1>
+{
+    public IMethodBodyGenerator UseProvidedBody(Action<TParam1> body) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBodyBuilderStage4NoArg<TReturnType> : IMethodBodyBuilderStage4NoArg<TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TReturnType> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyRetuningConstant(Func<TReturnType> constantValueFactory) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBodyBuilderStage4<TParam1, TReturnType> : IMethodBodyBuilderStage4<TParam1, TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyRetuningConstant(Func<TReturnType> constantValueFactory) => new MockMethodBodyGenerator();
+    public IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> BodyWithSwitchStatement() =>
+        new MockMethodImplementationGeneratorSwitchBody<TParam1, TReturnType>();
+}
+
+public class MockMethodBodyGenerator : IMethodBodyGenerator;
+
 public class MockMethodImplementationGenerator<TReturnType> : IMethodBodyGenerator<TReturnType>
 {
-    public IMethodBodyGenerator BodyReturningConstantValue(Func<object> body) => this;
+    public IMethodBodyGeneratorWithNoParameter BodyReturningConstantValue(Func<object> body) => new MockMethodBodyGeneratorWithNoParameter();
 }
 
+public class MockMethodBodyGeneratorWithNoParameter : IMethodBodyGeneratorWithNoParameter;
+
 public class MockMethodImplementationGenerator<TArg1, TReturnType> : IMethodBodyGenerator<TArg1, TReturnType>
 {
     public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> GenerateSwitchBody() =>
@@ -33,11 +92,11 @@ public IMethodBodyGeneratorSwitchBodyDefaultCase<TArg1, TReturnType> ForDefaultC
 public class MockMethodImplementationGeneratorSwitchBodyDefaultCase<TArg1, TReturnType> : IMethodBodyGeneratorSwitchBodyDefaultCase<TArg1,
     TReturnType>
 {
-    public IMethodBodyGenerator<TArg1, TReturnType> ReturnConstantValue(Func<TArg1, TReturnType> func)
-        => new MockMethodImplementationGenerator<TArg1, TReturnType>();
+    public IMethodBodyGenerator ReturnConstantValue(Func<TArg1, TReturnType> func)
+        => new MockMethodBodyGenerator();
 
-    public IMethodBodyGenerator<TArg1, TReturnType> UseProvidedBody(Func<TArg1, Func<TReturnType>> func)
-        => new MockMethodImplementationGenerator<TArg1, TReturnType>();
+    public IMethodBodyGenerator UseProvidedBody(Func<TArg1, TReturnType> func)
+        => new MockMethodBodyGenerator();
 }
 
 public class MockMethodImplementationGeneratorSwitchBodyCase<TArg1, TReturnType> : IMethodBodyGeneratorSwitchBodyCase<TArg1, TReturnType>
@@ -45,7 +104,7 @@ public class MockMethodImplementationGeneratorSwitchBodyCase<TArg1, TReturnType>
     public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> ReturnConstantValue(Func<TArg1, TReturnType> constantValueFactory)
         => new MockMethodImplementationGeneratorSwitchBody<TArg1, TReturnType>();
 
-    public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> UseBody(Func<TArg1, Action<TReturnType>> body)
+    public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> UseProvidedBody(Func<TArg1, TReturnType> body)
         => new MockMethodImplementationGeneratorSwitchBody<TArg1, TReturnType>();
 }
 
@@ -53,16 +112,111 @@ public class MockMethodBodyBuilder : IMethodBodyBuilder
 {
     public IMethodBodyBuilder<TArg1> WithParameter<TArg1>() => new MockMethodBodyBuilder<TArg1>();
 
-    public IMethodBodyGenerator<TReturnType> WithReturnType<TReturnType>() => new MockImplementationGenerator<TReturnType>();
-}
-
-public class MockImplementationGenerator<TReturnType> : IMethodBodyGenerator<TReturnType>
-{
-    public IMethodBodyGenerator BodyReturningConstantValue(Func<object> body) => this;
+    public IMethodBodyGenerator<TReturnType> WithReturnType<TReturnType>() => new MockMethodImplementationGenerator<TReturnType>();
 }
 
 public class MockMethodBodyBuilder<TArg1Input> : IMethodBodyBuilder<TArg1Input>
 {
     public IMethodBodyGenerator<TArg1Input, TReturnType> WithReturnType<TReturnType>()
         => new MockMethodImplementationGenerator<TArg1Input, TReturnType>();
+}
+
+// Mock implementations for Method builder (entire method generation)
+public class MockMethodBuilderStage1 : IMethodBuilderStage1
+{
+    public IMethodBuilderStage2 WithName(string name) => new MockMethodBuilderStage2();
+    public IMethodBuilderStage2 WithName(Func<string> nameFactory) => new MockMethodBuilderStage2();
+}
+
+public class MockMethodBuilderStage2 : IMethodBuilderStage2
+{
+    public IMethodBuilderStage3ReturningVoid WithVoidReturn() => new MockMethodBuilderStage3ReturningVoid();
+    public IMethodBuilderStage3<TReturnType> WithReturnType<TReturnType>() => new MockMethodBuilderStage3<TReturnType>();
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(Type returnType) => new MockMethodBuilderStage3WithSomeReturnType();
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(string returnType) => new MockMethodBuilderStage3WithSomeReturnType();
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(Func<Type> returnTypeFactory) => new MockMethodBuilderStage3WithSomeReturnType();
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(Func<string> returnTypeFactory) => new MockMethodBuilderStage3WithSomeReturnType();
+}
+
+public class MockMethodBuilderStage3ReturningVoid : IMethodBuilderStage3ReturningVoid
+{
+    public IMethodBuilderStage4ReturnVoidNoParam WithNoParameters() => new MockMethodBuilderStage4ReturnVoidNoParam();
+    public IMethodBuilderStage4ReturnVoid<TParam1> WithParameter<TParam1>() => new MockMethodBuilderStage4ReturnVoid<TParam1>();
+    public IMethodBuilderStage4ReturnVoid WithParameter(Type param1) => new MockMethodBuilderStage4ReturnVoidNonGeneric();
+    public IMethodBuilderStage4ReturnVoid WithParameter(string param1) => new MockMethodBuilderStage4ReturnVoidNonGeneric();
+    public IMethodBuilderStage4ReturnVoid WithParameter(Func<Type> param1Factory) => new MockMethodBuilderStage4ReturnVoidNonGeneric();
+    public IMethodBuilderStage4ReturnVoid WithParameter(Func<string> param1Factory) => new MockMethodBuilderStage4ReturnVoidNonGeneric();
+}
+
+public class MockMethodBuilderStage3<TReturnType> : IMethodBuilderStage3<TReturnType>
+{
+    public IMethodBuilderStage4NoParam<TReturnType> WithNoParameters() => new MockMethodBuilderStage4NoParam<TReturnType>();
+    public IMethodBuilderStage4<TParam1, TReturnType> WithParameter<TParam1>() => new MockMethodBuilderStage4<TParam1, TReturnType>();
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Type param1) => new MockMethodBuilderStage4WithSomeParam<TReturnType>();
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(string param1) => new MockMethodBuilderStage4WithSomeParam<TReturnType>();
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Func<Type> param1Factory) => new MockMethodBuilderStage4WithSomeParam<TReturnType>();
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Func<string> param1Factory) => new MockMethodBuilderStage4WithSomeParam<TReturnType>();
+}
+
+public class MockMethodBuilderStage3WithSomeReturnType : IMethodBuilderStage3WithSomeReturnType
+{
+    public IMethodBuilderStage4WithSomeReturnTypeNoParam WithNoParameters() => new MockMethodBuilderStage4WithSomeReturnTypeNoParam();
+    public IMethodBuilderStage4WithSomeReturnType<TParam1> WithParameter<TParam1>() => new MockMethodBuilderStage4WithSomeReturnType<TParam1>();
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(Type param1) => new MockMethodBuilderStage4WithSomeReturnTypeWithSomeParam();
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(string param1) => new MockMethodBuilderStage4WithSomeReturnTypeWithSomeParam();
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(Func<Type> param1Factory) => new MockMethodBuilderStage4WithSomeReturnTypeWithSomeParam();
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(Func<string> param1Factory) => new MockMethodBuilderStage4WithSomeReturnTypeWithSomeParam();
+}
+
+public class MockMethodBuilderStage4ReturnVoidNoParam : IMethodBuilderStage4ReturnVoidNoParam
+{
+    public IMethodBodyGenerator UseProvidedBody(Action body) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4ReturnVoid<TParam1> : IMethodBuilderStage4ReturnVoid<TParam1>
+{
+    public IMethodBodyGenerator UseProvidedBody(Action<TParam1> body) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4ReturnVoidNonGeneric : IMethodBuilderStage4ReturnVoid
+{
+    public IMethodBodyGenerator UseProvidedBody(Action<object> body) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4NoParam<TReturnType> : IMethodBuilderStage4NoParam<TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TReturnType> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4<TParam1, TReturnType> : IMethodBuilderStage4<TParam1, TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory) => new MockMethodBodyGenerator();
+    public IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> BodyWithSwitchStatement() =>
+        new MockMethodImplementationGeneratorSwitchBody<TParam1, TReturnType>();
+}
+
+public class MockMethodBuilderStage4WithSomeParam<TReturnType> : IMethodBuilderStage4WithSomeParam<TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<object, TReturnType> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4WithSomeReturnTypeNoParam : IMethodBuilderStage4WithSomeReturnTypeNoParam
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<object> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4WithSomeReturnType<TParam1> : IMethodBuilderStage4WithSomeReturnType<TParam1>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TParam1, object> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory) => new MockMethodBodyGenerator();
+}
+
+public class MockMethodBuilderStage4WithSomeReturnTypeWithSomeParam : IMethodBuilderStage4WithSomeReturnTypeWithSomeParam
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<object, object> body) => new MockMethodBodyGenerator();
+    public IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory) => new MockMethodBodyGenerator();
 }
\ No newline at end of file
diff --git a/EasySourceGenerators.Examples/ColorsClassFluentCreated.cs b/EasySourceGenerators.Examples/ColorsClassFluentCreated.cs
new file mode 100644
index 0000000..b3f05ab
--- /dev/null
+++ b/EasySourceGenerators.Examples/ColorsClassFluentCreated.cs
@@ -0,0 +1,23 @@
+using EasySourceGenerators.Abstractions;
+
+namespace EasySourceGenerators.Examples;
+
+public partial class ColorsClassFluentCreated
+{
+    [MethodBodyGenerator("GetAllColorsString")]
+    static IMethodBodyGenerator GetAllColorsString_Generator() =>
+        Generate.Method()
+            .WithName("GetAllColorsString")
+            .WithReturnType<string>()
+            .WithNoParameters()
+            .BodyReturningConstant(() => string.Join(", ", Enum.GetNames<ColorsEnum>()));
+}
+
+/*
+ This will generate the following method:
+
+    public string GetAllColorsString()
+    {
+        return "Red, Green, Blue";
+    }
+*/
diff --git a/EasySourceGenerators.Examples/MapperFluentCreated.cs b/EasySourceGenerators.Examples/MapperFluentCreated.cs
new file mode 100644
index 0000000..f4bad83
--- /dev/null
+++ b/EasySourceGenerators.Examples/MapperFluentCreated.cs
@@ -0,0 +1,36 @@
+using EasySourceGenerators.Abstractions;
+
+namespace EasySourceGenerators.Examples;
+
+public partial class MapperFluentCreated
+{
+    [MethodBodyGenerator("MapToMammal")]
+    static IMethodBodyGenerator MapToMammal_Generator() =>
+        Generate.Method()
+            .WithName("MapToMammal")
+            .WithReturnType<Mammal>()
+            .WithParameter<FourLegged>()
+            .BodyWithSwitchStatement()
+            .ForCases(GetFourLeggedAnimalsThatHasMatchInMammalAnimal()).ReturnConstantValue(fourLegged => Enum.Parse<Mammal>(fourLegged.ToString(), true))
+            .ForDefaultCase().UseProvidedBody(fourLegged => throw new ArgumentException($"Cannot map {fourLegged} to a Mammal"));
+
+    static FourLegged[] GetFourLeggedAnimalsThatHasMatchInMammalAnimal() =>
+        Enum
+            .GetValues<FourLegged>()
+            .Where(fourLeggedAnimal => Enum.TryParse(typeof(Mammal), fourLeggedAnimal.ToString(), true, out _))
+            .ToArray();
+}
+
+/*
+ This will generate the following method:
+
+    public Mammal MapToMammal(FourLegged fourLegged)
+    {
+        switch (fourLegged)
+        {
+            case FourLegged.Dog: return Mammal.Dog;
+            case FourLegged.Cat: return Mammal.Cat;
+            default: throw new ArgumentException($"Cannot map {fourLegged} to a Mammal");
+        }
+    }
+*/
diff --git a/EasySourceGenerators.GeneratorTests/GeneratesMethodExecutionRuntimeTests.cs b/EasySourceGenerators.GeneratorTests/GeneratesMethodExecutionRuntimeTests.cs
index 4ec682f..16cfede 100644
--- a/EasySourceGenerators.GeneratorTests/GeneratesMethodExecutionRuntimeTests.cs
+++ b/EasySourceGenerators.GeneratorTests/GeneratesMethodExecutionRuntimeTests.cs
@@ -222,8 +222,8 @@ public static IMethodBodyGenerator Generate()
 
                                                              private static IMethodBodyGenerator GenerateMethod()
                                                              {
-                                                                 return global::EasySourceGenerators.Abstractions.Generate.Method()
-                                                                     .WithOneParameter<int>()
+                                                                 return global::EasySourceGenerators.Abstractions.Generate.MethodBody()
+                                                                     .WithParameter<int>()
                                                                      .WithReturnType<int>()
                                                                      .GenerateSwitchBody()
                                                                      .ForCases(1, new[] { 2, 3 }, "4")
diff --git a/EasySourceGenerators.GeneratorTests/MethodBodyBuilderTests.cs b/EasySourceGenerators.GeneratorTests/MethodBodyBuilderTests.cs
index 311c7d9..faf1d7f 100644
--- a/EasySourceGenerators.GeneratorTests/MethodBodyBuilderTests.cs
+++ b/EasySourceGenerators.GeneratorTests/MethodBodyBuilderTests.cs
@@ -49,6 +49,8 @@ private sealed class TrackingGeneratorsFactory : IMethodBodyGeneratorStage0
         public int TypedCreateImplementationCalls { get; private set; }
         public int ArgCreateImplementationCalls { get; private set; }
 
+        public IMethodBodyGeneratorWithNoParameter CreateImplementation() => new TrackingNoParamGenerator();
+
         public IMethodBodyBuilder ForMethod() => new MethodBodyBuilder(this);
 
         public IMethodBodyGenerator<TReturnType> CreateImplementation<TReturnType>()
@@ -64,9 +66,12 @@ public IMethodBodyGenerator<TArg1, TReturnType> CreateImplementation<TArg1, TRet
         }
     }
 
+    private sealed class TrackingNoParamGenerator : IMethodBodyGeneratorWithNoParameter;
+
     private sealed class TrackingTypedImplementationGenerator<TReturnType> : IMethodBodyGenerator<TReturnType>
     {
-        public IMethodBodyGeneratorWithNoParameter BodyReturningConstantValue(Func<object> body) => this;
+        public IMethodBodyGeneratorWithNoParameter BodyReturningConstantValue(Func<object> body) =>
+            new TrackingNoParamGenerator();
     }
 
     private sealed class TrackingArgImplementationGenerator<TArg1, TReturnType> : IMethodBodyGenerator<TArg1, TReturnType>
diff --git a/EasySourceGenerators.GeneratorTests/MocksTests.cs b/EasySourceGenerators.GeneratorTests/MocksTests.cs
index 4e78fef..03270ae 100644
--- a/EasySourceGenerators.GeneratorTests/MocksTests.cs
+++ b/EasySourceGenerators.GeneratorTests/MocksTests.cs
@@ -36,13 +36,13 @@ public void MockGeneratorsFactory_CreateImplementationWithArg_ReturnsArgMock()
     }
 
     [Test]
-    public void MockMethodImplementationGeneratorTyped_UseBody_ReturnsSameInstance()
+    public void MockMethodImplementationGeneratorTyped_UseBody_ReturnsWithNoParameter()
     {
         MockMethodImplementationGenerator<string> generator = new MockMethodImplementationGenerator<string>();
 
         IMethodBodyGeneratorWithNoParameter result = generator.BodyReturningConstantValue(() => "x");
 
-        Assert.That(result, Is.SameAs(generator));
+        Assert.That(result, Is.TypeOf<MockMethodBodyGeneratorWithNoParameter>());
     }
 
     [Test]
@@ -76,23 +76,23 @@ public void MockSwitchBody_ForDefaultCase_ReturnsDefaultCaseMock()
     }
 
     [Test]
-    public void MockDefaultCase_ReturnConstantValue_ReturnsMethodImplementationGenerator()
+    public void MockDefaultCase_ReturnConstantValue_ReturnsMethodBodyGenerator()
     {
         MockMethodImplementationGeneratorSwitchBodyDefaultCase<int, string> defaultCase = new MockMethodImplementationGeneratorSwitchBodyDefaultCase<int, string>();
 
-        IMethodBodyGenerator<int, string> result = defaultCase.ReturnConstantValue(value => value.ToString());
+        IMethodBodyGenerator result = defaultCase.ReturnConstantValue(value => value.ToString());
 
-        Assert.That(result, Is.TypeOf<MockMethodImplementationGenerator<int, string>>());
+        Assert.That(result, Is.TypeOf<MockMethodBodyGenerator>());
     }
 
     [Test]
-    public void MockDefaultCase_UseBody_ReturnsMethodImplementationGenerator()
+    public void MockDefaultCase_UseProvidedBody_ReturnsMethodBodyGenerator()
     {
         MockMethodImplementationGeneratorSwitchBodyDefaultCase<int, string> defaultCase = new MockMethodImplementationGeneratorSwitchBodyDefaultCase<int, string>();
 
-        IMethodBodyGenerator<int, string> result = defaultCase.UseProvidedBody(_ => () => "v");
+        IMethodBodyGenerator result = defaultCase.UseProvidedBody(_ => "v");
 
-        Assert.That(result, Is.TypeOf<MockMethodImplementationGenerator<int, string>>());
+        Assert.That(result, Is.TypeOf<MockMethodBodyGenerator>());
     }
 
     [Test]
@@ -106,11 +106,11 @@ public void MockCase_ReturnConstantValue_ReturnsSwitchBody()
     }
 
     [Test]
-    public void MockCase_UseBody_ReturnsSwitchBody()
+    public void MockCase_UseProvidedBody_ReturnsSwitchBody()
     {
         MockMethodImplementationGeneratorSwitchBodyCase<int, string> caseBuilder = new MockMethodImplementationGeneratorSwitchBodyCase<int, string>();
 
-        IMethodBodyGeneratorSwitchBody<int, string> result = caseBuilder.UseBody(_ => _ => { });
+        IMethodBodyGeneratorSwitchBody<int, string> result = caseBuilder.UseProvidedBody(_ => "test");
 
         Assert.That(result, Is.TypeOf<MockMethodImplementationGeneratorSwitchBody<int, string>>());
     }
@@ -132,17 +132,17 @@ public void MockMethodBuilder_WithReturnType_ReturnsMockImplementationGenerator(
 
         IMethodBodyGenerator<string> result = bodyBuilder.WithReturnType<string>();
 
-        Assert.That(result, Is.TypeOf<MockImplementationGenerator<string>>());
+        Assert.That(result, Is.TypeOf<MockMethodImplementationGenerator<string>>());
     }
 
     [Test]
-    public void MockImplementationGenerator_UseBody_ReturnsSameInstance()
+    public void MockImplementationGenerator_UseBody_ReturnsWithNoParameter()
     {
-        MockImplementationGenerator<string> generator = new MockImplementationGenerator<string>();
+        MockMethodImplementationGenerator<string> generator = new MockMethodImplementationGenerator<string>();
 
         IMethodBodyGeneratorWithNoParameter result = generator.BodyReturningConstantValue(() => "x");
 
-        Assert.That(result, Is.SameAs(generator));
+        Assert.That(result, Is.TypeOf<MockMethodBodyGeneratorWithNoParameter>());
     }
 
     [Test]
diff --git a/EasySourceGenerators.GeneratorTests/RecordingGeneratorsFactoryTests.cs b/EasySourceGenerators.GeneratorTests/RecordingGeneratorsFactoryTests.cs
index 035c3f4..e735f5a 100644
--- a/EasySourceGenerators.GeneratorTests/RecordingGeneratorsFactoryTests.cs
+++ b/EasySourceGenerators.GeneratorTests/RecordingGeneratorsFactoryTests.cs
@@ -50,13 +50,13 @@ public void CreateImplementationWithArg_SetsLastRecordAndReturnsArgGenerator()
     }
 
     [Test]
-    public void TypedUseBody_ReturnsSameInstance()
+    public void TypedUseBody_ReturnsRecordingImplementationGenerator()
     {
         RecordingMethodImplementationGeneratorTyped<string> generator = new RecordingMethodImplementationGeneratorTyped<string>();
 
         IMethodBodyGeneratorWithNoParameter result = generator.BodyReturningConstantValue(() => "a");
 
-        Assert.That(result, Is.SameAs(generator));
+        Assert.That(result, Is.TypeOf<RecordingMethodImplementationGenerator>());
     }
 
     [Test]
@@ -103,7 +103,7 @@ public void UseBody_RecordsCaseKeysWithNullValues()
         RecordingMethodImplementationGeneratorSwitchBody<int, int> switchBody = new RecordingMethodImplementationGeneratorSwitchBody<int, int>(record);
         IMethodBodyGeneratorSwitchBodyCase<int, int> caseBuilder = switchBody.ForCases(5, 6);
 
-        IMethodBodyGeneratorSwitchBody<int, int> result = caseBuilder.UseProvidedBody(_ => _ => { });
+        IMethodBodyGeneratorSwitchBody<int, int> result = caseBuilder.UseProvidedBody(_ => 0);
 
         Assert.That(result, Is.TypeOf<RecordingMethodImplementationGeneratorSwitchBody<int, int>>());
         Assert.That(record.CaseKeys, Is.EqualTo(new object[] { 5, 6 }));
@@ -129,7 +129,7 @@ public void UseBody_WithNullCase_ThrowsInvalidOperationException()
         RecordingMethodImplementationGeneratorSwitchBody<string, int> switchBody = new RecordingMethodImplementationGeneratorSwitchBody<string, int>(record);
         IMethodBodyGeneratorSwitchBodyCase<string, int> caseBuilder = switchBody.ForCases((object?)null!);
 
-        TestDelegate action = () => caseBuilder.UseProvidedBody(_ => _ => { });
+        TestDelegate action = () => caseBuilder.UseProvidedBody(_ => 0);
 
         Assert.That(action, Throws.TypeOf<InvalidOperationException>());
     }
@@ -141,7 +141,7 @@ public void ForDefaultCase_ReturnConstantValue_SetsDefaultFlag()
         RecordingMethodImplementationGeneratorSwitchBody<int, int> switchBody = new RecordingMethodImplementationGeneratorSwitchBody<int, int>(record);
         IMethodBodyGeneratorSwitchBodyDefaultCase<int, int> defaultCase = switchBody.ForDefaultCase();
 
-        IMethodBodyGenerator<int, int> result = defaultCase.ReturnConstantValue(value => value + 1);
+        IMethodBodyGenerator result = defaultCase.ReturnConstantValue(value => value + 1);
 
         Assert.That(record.HasDefaultCase, Is.True);
         Assert.That(result, Is.TypeOf<RecordingMethodImplementationGenerator<int, int>>());
@@ -154,7 +154,7 @@ public void ForDefaultCase_UseBody_SetsDefaultFlag()
         RecordingMethodImplementationGeneratorSwitchBody<int, int> switchBody = new RecordingMethodImplementationGeneratorSwitchBody<int, int>(record);
         IMethodBodyGeneratorSwitchBodyDefaultCase<int, int> defaultCase = switchBody.ForDefaultCase();
 
-        IMethodBodyGenerator<int, int> result = defaultCase.UseProvidedBody(_ => () => 1);
+        IMethodBodyGenerator result = defaultCase.UseProvidedBody(_ => 1);
 
         Assert.That(record.HasDefaultCase, Is.True);
         Assert.That(result, Is.TypeOf<RecordingMethodImplementationGenerator<int, int>>());
diff --git a/EasySourceGenerators.Generators/Consts.cs b/EasySourceGenerators.Generators/Consts.cs
index 0b8ebfc..ca9b06e 100644
--- a/EasySourceGenerators.Generators/Consts.cs
+++ b/EasySourceGenerators.Generators/Consts.cs
@@ -19,4 +19,5 @@ public static class Consts
     public const string RecordingGeneratorsFactoryTypeFullName = $"{GeneratorsNamespace}.{nameof(RecordingGeneratorsFactory)}";
     public const string CurrentGeneratorPropertyName = nameof(Generate.CurrentGenerator);
     public const string LastRecordPropertyName = nameof(RecordingGeneratorsFactory.LastRecord);
+    public const string LastMethodRecordPropertyName = nameof(RecordingGeneratorsFactory.LastMethodRecord);
 }
diff --git a/EasySourceGenerators.Generators/EasySourceGenerators.Generators.csproj b/EasySourceGenerators.Generators/EasySourceGenerators.Generators.csproj
index 3560dc3..9919b08 100644
--- a/EasySourceGenerators.Generators/EasySourceGenerators.Generators.csproj
+++ b/EasySourceGenerators.Generators/EasySourceGenerators.Generators.csproj
@@ -60,7 +60,7 @@
     </Target>
 
     <ItemGroup>
-        <EmbeddedResource Include="MethodBodyBuilder.cs" LogicalName="$(RootNamespace).MethodBuilder.cs" />
+        <EmbeddedResource Include="MethodBodyBuilder.cs" LogicalName="$(RootNamespace).MethodBodyBuilder.cs" />
         <EmbeddedResource Include="RecordingGeneratorsFactory.cs" LogicalName="$(RootNamespace).RecordingGeneratorsFactory.cs"/>
     </ItemGroup>
 
diff --git a/EasySourceGenerators.Generators/GeneratesMethodExecutionRuntime.cs b/EasySourceGenerators.Generators/GeneratesMethodExecutionRuntime.cs
index 6c047c3..8f93263 100644
--- a/EasySourceGenerators.Generators/GeneratesMethodExecutionRuntime.cs
+++ b/EasySourceGenerators.Generators/GeneratesMethodExecutionRuntime.cs
@@ -14,6 +14,13 @@ internal sealed record SwitchBodyData(
     IReadOnlyList<(object key, string value)> CasePairs,
     bool HasDefaultCase);
 
+internal sealed record MethodData(
+    string MethodName,
+    string ReturnTypeName,
+    IReadOnlyList<string> ParameterTypeNames,
+    string? ConstantValue,
+    SwitchBodyData? SwitchBody);
+
 internal static class GeneratesMethodExecutionRuntime
 {
     internal static (string? value, string? error) ExecuteSimpleGeneratorMethod(
@@ -66,7 +73,9 @@ internal static (SwitchBodyData? record, string? error) ExecuteFluentGeneratorMe
                 {
                     Assembly loaded = context.LoadFromStream(new MemoryStream(bytes));
                     if (string.Equals(assemblyName.Name, Consts.AbstractionsAssemblyName, StringComparison.OrdinalIgnoreCase))
+                    {
                         capturedAbstractionsAssembly = loaded;
+                    }
                     return loaded;
                 }
 
@@ -179,6 +188,150 @@ reference.Display is not null
         }
     }
 
+    internal static (MethodData? methodData, string? error) ExecuteEntireMethodGeneratorMethod(
+        IMethodSymbol generatorMethod,
+        Compilation compilation)
+    {
+        IReadOnlyList<IMethodSymbol> allPartials = GetAllUnimplementedPartialMethods(compilation);
+        CSharpCompilation executableCompilation = BuildExecutionCompilation(allPartials, compilation);
+
+        using MemoryStream stream = new();
+        EmitResult emitResult = executableCompilation.Emit(stream);
+        if (!emitResult.Success)
+        {
+            string errors = string.Join("; ", emitResult.Diagnostics
+                .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
+                .Select(diagnostic => diagnostic.GetMessage()));
+            return (null, $"Compilation failed: {errors}");
+        }
+
+        stream.Position = 0;
+        AssemblyLoadContext? loadContext = null;
+        try
+        {
+            Dictionary<string, byte[]> compilationReferenceBytes = EmitCompilationReferences(compilation);
+
+            loadContext = new AssemblyLoadContext("__GeneratorExec", isCollectible: true);
+            Assembly? capturedAbstractionsAssembly = null;
+            loadContext.Resolving += (context, assemblyName) =>
+            {
+                PortableExecutableReference? match = compilation.References
+                    .OfType<PortableExecutableReference>()
+                    .FirstOrDefault(reference => reference.FilePath is not null && string.Equals(
+                        Path.GetFileNameWithoutExtension(reference.FilePath),
+                        assemblyName.Name,
+                        StringComparison.OrdinalIgnoreCase));
+                if (match?.FilePath != null)
+                    return context.LoadFromAssemblyPath(ResolveImplementationAssemblyPath(match.FilePath));
+
+                if (assemblyName.Name != null && compilationReferenceBytes.TryGetValue(assemblyName.Name, out byte[]? bytes))
+                {
+                    Assembly loaded = context.LoadFromStream(new MemoryStream(bytes));
+                    if (string.Equals(assemblyName.Name, Consts.AbstractionsAssemblyName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        capturedAbstractionsAssembly = loaded;
+                    }
+                    return loaded;
+                }
+
+                return null;
+            };
+
+            Assembly assembly = loadContext.LoadFromStream(stream);
+
+            MetadataReference[] abstractionsMatchingReferences = compilation.References.Where(reference => reference.Display is not null && (
+                    reference.Display.Equals(Consts.AbstractionsAssemblyName, StringComparison.OrdinalIgnoreCase)
+                    || (reference is PortableExecutableReference peRef && peRef.FilePath is not null && Path.GetFileNameWithoutExtension(peRef.FilePath)
+                        .Equals(Consts.AbstractionsAssemblyName, StringComparison.OrdinalIgnoreCase))))
+                .ToArray();
+
+            if (abstractionsMatchingReferences.Length == 0)
+            {
+                return (null, $"Could not find any reference matching '{Consts.AbstractionsAssemblyName}' in compilation references.");
+            }
+
+            PortableExecutableReference[] peMatchingReferences = abstractionsMatchingReferences.OfType<PortableExecutableReference>().ToArray();
+            CompilationReference[] csharpCompilationReference = abstractionsMatchingReferences.OfType<CompilationReference>().ToArray();
+            
+            Assembly abstractionsAssembly;
+            
+            if (peMatchingReferences.Length > 0)
+            {
+                PortableExecutableReference abstractionsReference = peMatchingReferences.First();
+                
+                if (string.IsNullOrEmpty(abstractionsReference.FilePath))
+                {
+                    return (null, $"The reference matching '{Consts.AbstractionsAssemblyName}' does not have a valid file path.");
+                }
+                
+                string abstractionsAssemblyPath = ResolveImplementationAssemblyPath(abstractionsReference.FilePath);
+                abstractionsAssembly = loadContext.LoadFromAssemblyPath(abstractionsAssemblyPath);
+            }
+            else if (csharpCompilationReference.Length > 0)
+            {
+                if (capturedAbstractionsAssembly != null)
+                {
+                    abstractionsAssembly = capturedAbstractionsAssembly;
+                }
+                else if (compilationReferenceBytes.TryGetValue(Consts.AbstractionsAssemblyName, out byte[]? abstractionBytes))
+                {
+                    abstractionsAssembly = loadContext.LoadFromStream(new MemoryStream(abstractionBytes));
+                }
+                else
+                {
+                    return (null, $"Found reference matching '{Consts.AbstractionsAssemblyName}' as a CompilationReference, but failed to emit it.");
+                }
+            }
+            else
+            {
+                return (null, $"Found references matching '{Consts.AbstractionsAssemblyName}' but none were usable.");
+            }
+            
+            Type? generatorStaticType = abstractionsAssembly.GetType(Consts.GenerateTypeFullName);
+            Type? recordingFactoryType = assembly.GetType(Consts.RecordingGeneratorsFactoryTypeFullName);
+            if (generatorStaticType == null || recordingFactoryType == null)
+            {
+                return (null, $"Could not find {Consts.GenerateTypeFullName} or {Consts.RecordingGeneratorsFactoryTypeFullName} types in compiled assembly");
+            }
+
+            object? recordingFactory = Activator.CreateInstance(recordingFactoryType);
+            PropertyInfo? currentGeneratorProperty = generatorStaticType.GetProperty(Consts.CurrentGeneratorPropertyName, BindingFlags.NonPublic | BindingFlags.Static);
+            currentGeneratorProperty?.SetValue(null, recordingFactory);
+
+            string typeName = generatorMethod.ContainingType.ToDisplayString();
+            Type? loadedType = assembly.GetType(typeName);
+            if (loadedType == null)
+            {
+                return (null, $"Could not find type '{typeName}' in compiled assembly");
+            }
+
+            MethodInfo? generatorMethodInfo = loadedType.GetMethod(generatorMethod.Name, BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+            if (generatorMethodInfo == null)
+            {
+                return (null, $"Could not find method '{generatorMethod.Name}' in type '{typeName}'");
+            }
+
+            generatorMethodInfo.Invoke(null, null);
+
+            PropertyInfo? lastMethodRecordProperty = recordingFactoryType.GetProperty(Consts.LastMethodRecordPropertyName);
+            object? lastMethodRecord = lastMethodRecordProperty?.GetValue(recordingFactory);
+            if (lastMethodRecord == null)
+            {
+                return (null, "RecordingGeneratorsFactory did not produce a method record");
+            }
+
+            return (ExtractMethodData(lastMethodRecord, recordingFactory, recordingFactoryType), null);
+        }
+        catch (Exception ex)
+        {
+            return (null, $"Error executing generator method '{generatorMethod.Name}': {ex.GetBaseException()}");
+        }
+        finally
+        {
+            loadContext?.Unload();
+        }
+    }
+
     internal static (string? value, string? error) ExecuteGeneratorMethodWithArgs(
         IMethodSymbol generatorMethod,
         IReadOnlyList<IMethodSymbol> allPartialMethods,
@@ -304,6 +457,58 @@ private static SwitchBodyData ExtractSwitchBodyData(object lastRecord, ITypeSymb
         return new SwitchBodyData(pairs, hasDefaultCase);
     }
 
+    private static MethodData ExtractMethodData(object lastMethodRecord, object? recordingFactory, Type recordingFactoryType)
+    {
+        Type methodRecordType = lastMethodRecord.GetType();
+        string methodName = methodRecordType.GetProperty(nameof(MethodRecord.MethodName))?.GetValue(lastMethodRecord)?.ToString() ?? string.Empty;
+        string returnTypeName = methodRecordType.GetProperty(nameof(MethodRecord.ReturnTypeName))?.GetValue(lastMethodRecord)?.ToString() ?? "void";
+        object? constantValue = methodRecordType.GetProperty(nameof(MethodRecord.ConstantValue))?.GetValue(lastMethodRecord);
+
+        IList? parameterTypeNamesList = methodRecordType.GetProperty(nameof(MethodRecord.ParameterTypeNames))?.GetValue(lastMethodRecord) as IList;
+        List<string> parameterTypeNames = new();
+        if (parameterTypeNamesList != null)
+        {
+            foreach (object? paramTypeName in parameterTypeNamesList)
+            {
+                parameterTypeNames.Add(paramTypeName?.ToString() ?? string.Empty);
+            }
+        }
+
+        // Check if there's a switch body record
+        object? switchBodyObj = methodRecordType.GetProperty(nameof(MethodRecord.SwitchBody))?.GetValue(lastMethodRecord);
+        SwitchBodyData? switchBodyData = null;
+        if (switchBodyObj != null)
+        {
+            // Also check the LastRecord from the factory for case pairs
+            PropertyInfo? lastRecordProperty = recordingFactoryType.GetProperty(Consts.LastRecordPropertyName);
+            object? lastRecord = lastRecordProperty?.GetValue(recordingFactory);
+            if (lastRecord != null)
+            {
+                Type switchRecordType = lastRecord.GetType();
+                IList caseKeys = (switchRecordType.GetProperty(nameof(SwitchBodyRecord.CaseKeys))?.GetValue(lastRecord) as IList) ?? new List<object>();
+                IList caseValues = (switchRecordType.GetProperty(nameof(SwitchBodyRecord.CaseValues))?.GetValue(lastRecord) as IList) ?? new List<object?>();
+                bool hasDefaultCase = (bool)(switchRecordType.GetProperty(nameof(SwitchBodyRecord.HasDefaultCase))?.GetValue(lastRecord) ?? false);
+
+                List<(object key, string value)> pairs = new();
+                for (int index = 0; index < caseKeys.Count; index++)
+                {
+                    object key = caseKeys[index]!;
+                    string? value = index < caseValues.Count ? caseValues[index]?.ToString() : null;
+                    pairs.Add((key, value ?? "default"));
+                }
+
+                switchBodyData = new SwitchBodyData(pairs, hasDefaultCase);
+            }
+        }
+
+        return new MethodData(
+            methodName,
+            returnTypeName,
+            parameterTypeNames,
+            constantValue?.ToString(),
+            switchBodyData);
+    }
+
     private static Dictionary<string, byte[]> EmitCompilationReferences(Compilation compilation)
     {
         Dictionary<string, byte[]> result = new(StringComparer.OrdinalIgnoreCase);
@@ -338,7 +543,8 @@ private static CSharpCompilation BuildExecutionCompilation(
         IReadOnlyList<IMethodSymbol> allPartialMethods,
         Compilation compilation)
     {
-        string dummySource = BuildDummyImplementation(allPartialMethods);
+        List<EntireMethodDummy> entireMethodDummies = GetEntireMethodDummies(compilation);
+        string dummySource = BuildDummyImplementation(allPartialMethods, entireMethodDummies);
         string methodBuilderSource = ReadEmbeddedResource($"{Consts.GeneratorsAssemblyName}.MethodBodyBuilder.cs");
         string recordingFactorySource = ReadEmbeddedResource($"{Consts.GeneratorsAssemblyName}.RecordingGeneratorsFactory.cs");
         CSharpParseOptions parseOptions = compilation.SyntaxTrees.FirstOrDefault()?.Options as CSharpParseOptions
@@ -360,7 +566,111 @@ private static string ReadEmbeddedResource(string resourceName)
         return reader.ReadToEnd();
     }
 
-    private static string BuildDummyImplementation(IEnumerable<IMethodSymbol> partialMethods)
+    private sealed record EntireMethodDummy(
+        string? Namespace,
+        string TypeName,
+        bool IsStatic,
+        TypeKind TypeKind,
+        string MethodName,
+        string ReturnType,
+        List<string> ParameterTypes);
+
+    private static List<EntireMethodDummy> GetEntireMethodDummies(Compilation compilation)
+    {
+        List<EntireMethodDummy> dummies = new();
+
+        foreach (SyntaxTree syntaxTree in compilation.SyntaxTrees)
+        {
+            SemanticModel semanticModel = compilation.GetSemanticModel(syntaxTree);
+            IEnumerable<MethodDeclarationSyntax> methods = syntaxTree.GetRoot().DescendantNodes()
+                .OfType<MethodDeclarationSyntax>();
+
+            foreach (MethodDeclarationSyntax method in methods)
+            {
+                if (semanticModel.GetDeclaredSymbol(method) is not IMethodSymbol methodSymbol)
+                    continue;
+
+                // Check if it has [MethodBodyGenerator] attribute and returns IMethodBodyGenerator
+                if (methodSymbol.ReturnType.ToDisplayString() != Consts.IMethodImplementationGeneratorFullName)
+                    continue;
+
+                AttributeData? attribute = methodSymbol.GetAttributes()
+                    .FirstOrDefault(a => a.AttributeClass?.ToDisplayString() == Consts.GeneratesMethodAttributeFullName);
+                if (attribute == null)
+                    continue;
+
+                string? targetMethodName = attribute.ConstructorArguments.FirstOrDefault().Value?.ToString();
+                if (targetMethodName == null)
+                    continue;
+
+                // Check if the target method already exists as a partial method
+                INamedTypeSymbol containingType = methodSymbol.ContainingType;
+                bool hasPartialMethod = containingType.GetMembers(targetMethodName)
+                    .OfType<IMethodSymbol>()
+                    .Any(m => m.IsPartialDefinition);
+                if (hasPartialMethod)
+                    continue;
+
+                // This is an entire method generation target - extract signature from fluent API
+                EntireMethodDummy? dummy = ExtractMethodSignatureFromFluent(method, methodSymbol, targetMethodName);
+                if (dummy != null)
+                    dummies.Add(dummy);
+            }
+        }
+
+        return dummies;
+    }
+
+    private static EntireMethodDummy? ExtractMethodSignatureFromFluent(
+        MethodDeclarationSyntax method,
+        IMethodSymbol methodSymbol,
+        string targetMethodName)
+    {
+        INamedTypeSymbol containingType = methodSymbol.ContainingType;
+
+        // Try to extract return type and parameters from the fluent API calls
+        string returnType = "object";
+        List<string> parameterTypes = new();
+
+        IEnumerable<InvocationExpressionSyntax> invocations = method.DescendantNodes().OfType<InvocationExpressionSyntax>();
+        foreach (InvocationExpressionSyntax invocation in invocations)
+        {
+            if (invocation.Expression is not MemberAccessExpressionSyntax memberAccess)
+                continue;
+
+            string callName = memberAccess.Name.Identifier.Text;
+
+            if (callName == "WithReturnType" && memberAccess.Name is GenericNameSyntax returnTypeGeneric
+                && returnTypeGeneric.TypeArgumentList.Arguments.Count == 1)
+            {
+                returnType = returnTypeGeneric.TypeArgumentList.Arguments[0].ToString();
+            }
+
+            if (callName == "WithParameter" && memberAccess.Name is GenericNameSyntax paramGeneric
+                && paramGeneric.TypeArgumentList.Arguments.Count == 1)
+            {
+                parameterTypes.Add(paramGeneric.TypeArgumentList.Arguments[0].ToString());
+            }
+
+            if (callName == "WithVoidReturn")
+            {
+                returnType = "void";
+            }
+        }
+
+        return new EntireMethodDummy(
+            containingType.ContainingNamespace?.IsGlobalNamespace == false
+                ? containingType.ContainingNamespace.ToDisplayString()
+                : null,
+            containingType.Name,
+            containingType.IsStatic,
+            containingType.TypeKind,
+            targetMethodName,
+            returnType,
+            parameterTypes);
+    }
+
+    private static string BuildDummyImplementation(IEnumerable<IMethodSymbol> partialMethods, List<EntireMethodDummy> entireMethodDummies)
     {
         StringBuilder builder = new();
 
@@ -421,6 +731,45 @@ private static string BuildDummyImplementation(IEnumerable<IMethodSymbol> partia
             }
         }
 
+        // Add dummy methods for entire method generation targets
+        IEnumerable<IGrouping<(string? Namespace, string TypeName, bool IsStatic, TypeKind TypeKind), EntireMethodDummy>> entireMethodGroups =
+            entireMethodDummies.GroupBy(d => (d.Namespace, d.TypeName, d.IsStatic, d.TypeKind));
+
+        foreach (IGrouping<(string? Namespace, string TypeName, bool IsStatic, TypeKind TypeKind), EntireMethodDummy> group in entireMethodGroups)
+        {
+            string? ns = group.Key.Namespace;
+            if (ns != null)
+            {
+                builder.AppendLine($"namespace {ns} {{");
+            }
+
+            string typeKeyword = group.Key.TypeKind switch
+            {
+                TypeKind.Struct => "struct",
+                _ => "class"
+            };
+
+            string typeModifiers = group.Key.IsStatic ? "static partial" : "partial";
+            builder.AppendLine($"{typeModifiers} {typeKeyword} {group.Key.TypeName} {{");
+
+            foreach (EntireMethodDummy dummy in group)
+            {
+                string staticModifier = group.Key.IsStatic ? "static " : "";
+                string parameters = string.Join(", ", dummy.ParameterTypes.Select((type, index) => $"{type} arg{index}"));
+                string body = dummy.ReturnType == "void"
+                    ? "{ }"
+                    : $"{{ return default({dummy.ReturnType})!; }}";
+                builder.AppendLine($"public {staticModifier}{dummy.ReturnType} {dummy.MethodName}({parameters}) {body}");
+            }
+
+            builder.AppendLine("}");
+
+            if (ns != null)
+            {
+                builder.AppendLine("}");
+            }
+        }
+
         return builder.ToString();
     }
 }
diff --git a/EasySourceGenerators.Generators/GeneratesMethodGenerationPipeline.cs b/EasySourceGenerators.Generators/GeneratesMethodGenerationPipeline.cs
index 22c8858..5726ed9 100644
--- a/EasySourceGenerators.Generators/GeneratesMethodGenerationPipeline.cs
+++ b/EasySourceGenerators.Generators/GeneratesMethodGenerationPipeline.cs
@@ -50,24 +50,30 @@ private static string GenerateSourceForGroup(
         bool hasSwitchCase = methods.Any(method => HasAttribute(method.Symbol, SwitchCaseAttributeFullName));
         bool hasSwitchDefault = methods.Any(method => HasAttribute(method.Symbol, SwitchDefaultAttributeFullName));
         bool isFluentPattern = methods.Count == 1 && methods[0].Symbol.ReturnType.ToDisplayString() == IMethodImplementationGeneratorFullName;
+        bool isEntireMethodGeneration = firstMethod.PartialMethod is null;
 
         if (hasSwitchCase || hasSwitchDefault)
         {
             return GeneratesMethodPatternSourceBuilder.GenerateFromSwitchAttributes(
                 context,
                 methods,
-                firstMethod.PartialMethod,
+                firstMethod.PartialMethod!,
                 firstMethod.ContainingType,
                 allPartials,
                 compilation);
         }
 
+        if (isFluentPattern && isEntireMethodGeneration)
+        {
+            return GenerateFromEntireMethodPattern(context, methods[0], compilation);
+        }
+
         if (isFluentPattern)
         {
             return GeneratesMethodPatternSourceBuilder.GenerateFromFluent(
                 context,
                 methods[0],
-                firstMethod.PartialMethod,
+                firstMethod.PartialMethod!,
                 firstMethod.ContainingType,
                 compilation);
         }
@@ -97,7 +103,7 @@ private static string GenerateFromSimplePattern(
     {
         (string? returnValue, string? error) = GeneratesMethodExecutionRuntime.ExecuteSimpleGeneratorMethod(
             firstMethod.Symbol,
-            firstMethod.PartialMethod,
+            firstMethod.PartialMethod!,
             compilation);
 
         if (error != null)
@@ -112,10 +118,52 @@ private static string GenerateFromSimplePattern(
 
         return GeneratesMethodPatternSourceBuilder.GenerateSimplePartialMethod(
             firstMethod.ContainingType,
-            firstMethod.PartialMethod,
+            firstMethod.PartialMethod!,
             returnValue);
     }
 
+    private static string GenerateFromEntireMethodPattern(
+        SourceProductionContext context,
+        GeneratesMethodGenerationTarget methodInfo,
+        Compilation compilation)
+    {
+        (MethodData? methodData, string? error) = GeneratesMethodExecutionRuntime.ExecuteEntireMethodGeneratorMethod(
+            methodInfo.Symbol,
+            compilation);
+
+        if (error != null)
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                GeneratesMethodGeneratorDiagnostics.GeneratorMethodExecutionError,
+                methodInfo.Syntax.GetLocation(),
+                methodInfo.Symbol.Name,
+                error));
+            return string.Empty;
+        }
+
+        MethodData data = methodData!;
+
+        if (data.SwitchBody != null)
+        {
+            (string? defaultExpression, List<string> lambdaParamNames) = GeneratesMethodPatternSourceBuilder.ExtractDefaultExpressionAndParamNames(methodInfo.Syntax);
+
+            if (!data.SwitchBody.HasDefaultCase)
+            {
+                defaultExpression = null;
+            }
+
+            return GeneratesMethodPatternSourceBuilder.GenerateEntireMethodWithSwitch(
+                methodInfo.ContainingType,
+                data,
+                defaultExpression,
+                lambdaParamNames);
+        }
+
+        return GeneratesMethodPatternSourceBuilder.GenerateEntireMethodSimple(
+            methodInfo.ContainingType,
+            data);
+    }
+
     private static bool HasAttribute(IMethodSymbol methodSymbol, string fullAttributeTypeName)
     {
         return methodSymbol.GetAttributes()
diff --git a/EasySourceGenerators.Generators/GeneratesMethodGenerationTargetCollector.cs b/EasySourceGenerators.Generators/GeneratesMethodGenerationTargetCollector.cs
index 8c4d7ea..4fc0131 100644
--- a/EasySourceGenerators.Generators/GeneratesMethodGenerationTargetCollector.cs
+++ b/EasySourceGenerators.Generators/GeneratesMethodGenerationTargetCollector.cs
@@ -10,7 +10,7 @@ internal sealed record GeneratesMethodGenerationTarget(
     MethodDeclarationSyntax Syntax,
     IMethodSymbol Symbol,
     string TargetMethodName,
-    IMethodSymbol PartialMethod,
+    IMethodSymbol? PartialMethod,
     INamedTypeSymbol ContainingType);
 
 internal static class GeneratesMethodGenerationTargetCollector
@@ -83,7 +83,9 @@ internal static List<GeneratesMethodGenerationTarget> Collect(
                 .OfType<IMethodSymbol>()
                 .FirstOrDefault(method => method.IsPartialDefinition);
 
-            if (partialMethodSymbol is null)
+            bool isFluentPattern = methodSymbol.ReturnType.ToDisplayString() == IMethodImplementationGeneratorFullName;
+
+            if (partialMethodSymbol is null && !isFluentPattern)
             {
                 Location? attributeLocation = attribute.ApplicationSyntaxReference?.GetSyntax().GetLocation();
                 
diff --git a/EasySourceGenerators.Generators/GeneratesMethodPatternSourceBuilder.cs b/EasySourceGenerators.Generators/GeneratesMethodPatternSourceBuilder.cs
index ab044d9..d7288f9 100644
--- a/EasySourceGenerators.Generators/GeneratesMethodPatternSourceBuilder.cs
+++ b/EasySourceGenerators.Generators/GeneratesMethodPatternSourceBuilder.cs
@@ -175,7 +175,7 @@ internal static string GenerateSimplePartialMethod(
         return ExtractInnermostLambdaBody(bodyExpression);
     }
 
-    private static string? ExtractDefaultExpressionFromFluentMethod(MethodDeclarationSyntax method)
+    internal static (string? expression, List<string> lambdaParamNames) ExtractDefaultExpressionAndParamNames(MethodDeclarationSyntax method)
     {
         IEnumerable<InvocationExpressionSyntax> invocations = method.DescendantNodes().OfType<InvocationExpressionSyntax>();
         foreach (InvocationExpressionSyntax invocation in invocations)
@@ -186,16 +186,57 @@ internal static string GenerateSimplePartialMethod(
             }
 
             string methodName = memberAccessExpression.Name.Identifier.Text;
-            if (methodName is not ("ReturnConstantValue" or "BodyReturningConstantValue"))
+            if (methodName is not ("ReturnConstantValue" or "BodyReturningConstantValue" or "UseProvidedBody" or "BodyRetuningConstant"))
             {
                 continue;
             }
 
-            ExpressionSyntax? argumentExpression = invocation.ArgumentList.Arguments.FirstOrDefault()?.Expression;
-            return ExtractInnermostLambdaBody(argumentExpression);
+            // Check if this method is called on the result of ForDefaultCase()
+            if (memberAccessExpression.Expression is InvocationExpressionSyntax receiverInvocation
+                && receiverInvocation.Expression is MemberAccessExpressionSyntax receiverMember
+                && receiverMember.Name.Identifier.Text == "ForDefaultCase")
+            {
+                ExpressionSyntax? argumentExpression = invocation.ArgumentList.Arguments.FirstOrDefault()?.Expression;
+                List<string> paramNames = ExtractLambdaParameterNames(argumentExpression);
+                string? body = ExtractInnermostLambdaBody(argumentExpression);
+                return (body, paramNames);
+            }
         }
 
-        return null;
+        return (null, new List<string>());
+    }
+
+    internal static string? ExtractDefaultExpressionFromFluentMethod(MethodDeclarationSyntax method)
+    {
+        (string? expression, _) = ExtractDefaultExpressionAndParamNames(method);
+        return expression;
+    }
+
+    private static List<string> ExtractLambdaParameterNames(ExpressionSyntax? expression)
+    {
+        List<string> names = new();
+        while (expression != null)
+        {
+            if (expression is SimpleLambdaExpressionSyntax simpleLambda)
+            {
+                names.Add(simpleLambda.Parameter.Identifier.Text);
+                expression = simpleLambda.Body as ExpressionSyntax;
+            }
+            else if (expression is ParenthesizedLambdaExpressionSyntax parenthesizedLambda)
+            {
+                foreach (ParameterSyntax parameter in parenthesizedLambda.ParameterList.Parameters)
+                {
+                    names.Add(parameter.Identifier.Text);
+                }
+                expression = parenthesizedLambda.Body as ExpressionSyntax;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        return names;
     }
 
     private static string? ExtractInnermostLambdaBody(ExpressionSyntax? expression)
@@ -259,6 +300,194 @@ private static string GenerateSwitchMethodSource(
         return builder.ToString();
     }
 
+    internal static string GenerateEntireMethodSimple(
+        INamedTypeSymbol containingType,
+        MethodData methodData)
+    {
+        StringBuilder builder = new();
+        AppendNamespaceAndTypeHeaderForEntireMethod(builder, containingType, methodData);
+
+        if (methodData.ReturnTypeName != "void" && methodData.ConstantValue != null)
+        {
+            string literal = FormatValueAsCSharpLiteralByTypeName(methodData.ConstantValue, methodData.ReturnTypeName);
+            builder.AppendLine($"        return {literal};");
+        }
+
+        builder.AppendLine("    }");
+        builder.AppendLine("}");
+        return builder.ToString();
+    }
+
+    internal static string GenerateEntireMethodWithSwitch(
+        INamedTypeSymbol containingType,
+        MethodData methodData,
+        string? defaultExpression,
+        List<string> lambdaParamNames)
+    {
+        StringBuilder builder = new();
+        List<string> paramNames = lambdaParamNames.Count >= methodData.ParameterTypeNames.Count
+            ? lambdaParamNames
+            : new List<string>();
+        AppendNamespaceAndTypeHeaderForEntireMethod(builder, containingType, methodData, paramNames);
+
+        if (methodData.ParameterTypeNames.Count == 0)
+        {
+            string fallbackExpression = defaultExpression ?? "default";
+            builder.AppendLine($"        return {fallbackExpression};");
+            builder.AppendLine("    }");
+            builder.AppendLine("}");
+            return builder.ToString();
+        }
+
+        string switchParameterName = paramNames.Count > 0 ? paramNames[0] : GetParameterName(methodData.ParameterTypeNames[0]);
+        builder.AppendLine($"        switch ({switchParameterName})");
+        builder.AppendLine("        {");
+
+        SwitchBodyData switchBody = methodData.SwitchBody!;
+        string? parameterTypeName = methodData.ParameterTypeNames.Count > 0 ? methodData.ParameterTypeNames[0] : null;
+        foreach ((object key, string value) in switchBody.CasePairs)
+        {
+            string formattedKey = FormatKeyAsCSharpLiteralByTypeName(key, parameterTypeName);
+            string formattedValue = FormatValueByReturnTypeName(value, methodData.ReturnTypeName);
+            builder.AppendLine($"            case {formattedKey}: return {formattedValue};");
+        }
+
+        if (defaultExpression != null)
+        {
+            string defaultStatement = defaultExpression.TrimStart().StartsWith("throw ", StringComparison.Ordinal)
+                ? $"            default: {defaultExpression};"
+                : $"            default: return {defaultExpression};";
+            builder.AppendLine(defaultStatement);
+        }
+
+        builder.AppendLine("        }");
+        builder.AppendLine("    }");
+        builder.AppendLine("}");
+        return builder.ToString();
+    }
+
+    private static void AppendNamespaceAndTypeHeaderForEntireMethod(StringBuilder builder, INamedTypeSymbol containingType, MethodData methodData, List<string>? parameterNames = null)
+    {
+        builder.AppendLine("// <auto-generated/>");
+        builder.AppendLine($"// Generated by {typeof(GeneratesMethodGenerator).FullName} for method '{methodData.MethodName}'.");
+        builder.AppendLine("#pragma warning disable");
+        builder.AppendLine();
+
+        string? namespaceName = containingType.ContainingNamespace?.IsGlobalNamespace == false
+            ? containingType.ContainingNamespace.ToDisplayString()
+            : null;
+        if (namespaceName != null)
+        {
+            builder.AppendLine($"namespace {namespaceName};");
+            builder.AppendLine();
+        }
+
+        string typeKeyword = containingType.TypeKind switch
+        {
+            TypeKind.Struct => "struct",
+            TypeKind.Interface => "interface",
+            _ => "class"
+        };
+
+        string typeModifiers = containingType.IsStatic ? "static partial" : "partial";
+        builder.AppendLine($"{typeModifiers} {typeKeyword} {containingType.Name}");
+        builder.AppendLine("{");
+
+        string returnTypeName = methodData.ReturnTypeName;
+        string methodName = methodData.MethodName;
+        string parameters = BuildParameterList(methodData.ParameterTypeNames, parameterNames);
+        string staticModifier = containingType.IsStatic ? "static " : "";
+
+        builder.AppendLine($"    public {staticModifier}{returnTypeName} {methodName}({parameters})");
+        builder.AppendLine("    {");
+    }
+
+    private static string BuildParameterList(IReadOnlyList<string> parameterTypeNames, List<string>? parameterNames = null)
+    {
+        List<string> parameters = new();
+        for (int index = 0; index < parameterTypeNames.Count; index++)
+        {
+            string paramName = (parameterNames != null && index < parameterNames.Count)
+                ? parameterNames[index]
+                : GetParameterName(parameterTypeNames[index]);
+            parameters.Add($"{parameterTypeNames[index]} {paramName}");
+        }
+        return string.Join(", ", parameters);
+    }
+
+    private static string GetParameterName(string typeName)
+    {
+        string simpleName = typeName.Contains('.') ? typeName.Substring(typeName.LastIndexOf('.') + 1) : typeName;
+        return char.ToLowerInvariant(simpleName[0]) + simpleName.Substring(1);
+    }
+
+    private static string FormatValueAsCSharpLiteralByTypeName(string? value, string returnTypeName)
+    {
+        if (value == null)
+        {
+            return "default";
+        }
+
+        if (returnTypeName == "System.String" || returnTypeName == "string")
+        {
+            return SyntaxFactory.Literal(value).Text;
+        }
+
+        if (returnTypeName == "System.Boolean" || returnTypeName == "bool")
+        {
+            return value.ToLowerInvariant();
+        }
+
+        return value;
+    }
+
+    private static string FormatKeyAsCSharpLiteralByTypeName(object key, string? parameterTypeName)
+    {
+        if (key is bool b)
+        {
+            return b ? "true" : "false";
+        }
+
+        if (key is string s)
+        {
+            return SyntaxFactory.Literal(s).Text;
+        }
+
+        // Check if it looks like an enum value (the key is the enum name)
+        if (parameterTypeName != null && key.GetType().IsEnum)
+        {
+            return $"{parameterTypeName}.{key}";
+        }
+
+        return key.ToString()!;
+    }
+
+    private static string FormatValueByReturnTypeName(string value, string returnTypeName)
+    {
+        // Check if the return type looks like an enum (contains a dot and doesn't start with System.)
+        // For enum values, the value will be the enum name, so prefix with the type
+        if (!string.IsNullOrEmpty(returnTypeName)
+            && returnTypeName != "System.String" && returnTypeName != "string"
+            && returnTypeName != "System.Int32" && returnTypeName != "int"
+            && returnTypeName != "System.Boolean" && returnTypeName != "bool"
+            && !returnTypeName.StartsWith("System.", StringComparison.Ordinal))
+        {
+            return $"{returnTypeName}.{value}";
+        }
+
+        if (returnTypeName == "System.String" || returnTypeName == "string")
+        {
+            return SyntaxFactory.Literal(value).Text;
+        }
+
+        if (returnTypeName == "System.Boolean" || returnTypeName == "bool")
+        {
+            return value.ToLowerInvariant();
+        }
+
+        return value;
+    }
+
     private static void AppendNamespaceAndTypeHeader(StringBuilder builder, INamedTypeSymbol containingType, IMethodSymbol partialMethod)
     {
         builder.AppendLine("// <auto-generated/>");
diff --git a/EasySourceGenerators.Generators/MethodBodyBuilder.cs b/EasySourceGenerators.Generators/MethodBodyBuilder.cs
index ba2900d..5120745 100644
--- a/EasySourceGenerators.Generators/MethodBodyBuilder.cs
+++ b/EasySourceGenerators.Generators/MethodBodyBuilder.cs
@@ -1,14 +1,73 @@
+using System;
 using EasySourceGenerators.Abstractions;
 
 namespace EasySourceGenerators.Generators;
 
-public class MethodBodyBuilder(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilder
+public class MethodBodyBuilder(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage1
 {
+    public IMethodBodyBuilderStage2 ForMethod() => new MethodBodyBuilderStage2(generatorsFactory);
+
     public IMethodBodyBuilder<TArg1> WithParameter<TArg1>() => new MethodBodyBodyBuilder<TArg1>(generatorsFactory);
 
     public IMethodBodyGenerator<TReturnType> WithReturnType<TReturnType>() => generatorsFactory.CreateImplementation<TReturnType>();
 }
 
+public class MethodBodyBuilderStage2(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage2
+{
+    public IMethodBodyBuilderStage3ReturnVoid WithVoidReturnType() => new MethodBodyBuilderStage3ReturnVoid(generatorsFactory);
+
+    public IMethodBodyBuilderStage3<TReturnType> WithReturnType<TReturnType>() => new MethodBodyBuilderStage3<TReturnType>(generatorsFactory);
+}
+
+public class MethodBodyBuilderStage3ReturnVoid(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage3ReturnVoid
+{
+    public IMethodBodyBuilderStage4ReturnVoidNoArg WithNoParameters() => new MethodBodyBuilderStage4ReturnVoidNoArg(generatorsFactory);
+
+    public IMethodBodyBuilderStage4ReturnVoid<TParam1> WithOneParameter<TParam1>() => new MethodBodyBuilderStage4ReturnVoid<TParam1>(generatorsFactory);
+}
+
+public class MethodBodyBuilderStage3<TReturnType>(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage3<TReturnType>
+{
+    public IMethodBodyBuilderStage4NoArg<TReturnType> WithNoParameters() => new MethodBodyBuilderStage4NoArg<TReturnType>(generatorsFactory);
+
+    public IMethodBodyBuilderStage4<TParam1, TReturnType> WithOneParameter<TParam1>() =>
+        new MethodBodyBuilderStage4<TParam1, TReturnType>(generatorsFactory);
+}
+
+public class MethodBodyBuilderStage4ReturnVoidNoArg(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage4ReturnVoidNoArg
+{
+    public IMethodBodyGenerator UseProvidedBody(Action body)
+    {
+        body();
+        return generatorsFactory.CreateImplementation();
+    }
+}
+
+public class MethodBodyBuilderStage4ReturnVoid<TParam1>(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage4ReturnVoid<TParam1>
+{
+    public IMethodBodyGenerator UseProvidedBody(Action<TParam1> body) => generatorsFactory.CreateImplementation();
+}
+
+public class MethodBodyBuilderStage4NoArg<TReturnType>(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage4NoArg<TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TReturnType> body) => generatorsFactory.CreateImplementation();
+
+    public IMethodBodyGenerator BodyRetuningConstant(Func<TReturnType> constantValueFactory) =>
+        generatorsFactory.CreateImplementation<TReturnType>();
+}
+
+public class MethodBodyBuilderStage4<TParam1, TReturnType>(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilderStage4<TParam1, TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body) =>
+        generatorsFactory.CreateImplementation<TParam1, TReturnType>();
+
+    public IMethodBodyGenerator BodyRetuningConstant(Func<TReturnType> constantValueFactory) =>
+        generatorsFactory.CreateImplementation<TParam1, TReturnType>();
+
+    public IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> BodyWithSwitchStatement() =>
+        generatorsFactory.CreateImplementation<TParam1, TReturnType>().GenerateSwitchBody();
+}
+
 public class MethodBodyBodyBuilder<TArg1>(IMethodBodyGeneratorStage0 generatorsFactory) : IMethodBodyBuilder<TArg1>
 {
     public IMethodBodyGenerator<TArg1, TReturnType> WithReturnType<TReturnType>() => generatorsFactory.CreateImplementation<TArg1, TReturnType>();
diff --git a/EasySourceGenerators.Generators/RecordingGeneratorsFactory.cs b/EasySourceGenerators.Generators/RecordingGeneratorsFactory.cs
index 56f2592..d70283b 100644
--- a/EasySourceGenerators.Generators/RecordingGeneratorsFactory.cs
+++ b/EasySourceGenerators.Generators/RecordingGeneratorsFactory.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using EasySourceGenerators.Abstractions;
+using EasySourceGenerators.Abstractions.Method;
 
 namespace EasySourceGenerators.Generators;
 
@@ -12,9 +13,30 @@ public class SwitchBodyRecord
     public bool HasDefaultCase { get; set; }
 }
 
-public class RecordingGeneratorsFactory : IMethodBodyGeneratorStage0
+public class MethodRecord
+{
+    public string? MethodName { get; set; }
+    public string? ReturnTypeName { get; set; }
+    public List<string> ParameterTypeNames { get; } = new();
+    public object? ConstantValue { get; set; }
+    public SwitchBodyRecord? SwitchBody { get; set; }
+    public bool IsEntireMethodGeneration { get; set; }
+}
+
+public class RecordingGeneratorsFactory : IMethodBodyGeneratorStage0, IGeneratorsFactory
 {
     public SwitchBodyRecord? LastRecord { get; private set; }
+    public MethodRecord? LastMethodRecord { get; private set; }
+
+    public IMethodBodyBuilderStage1 StartFluentApiBuilderForBody() => new MethodBodyBuilder(this);
+
+    public IMethodBuilderStage1 StartFluentApiBuilderForMethod()
+    {
+        MethodRecord record = new MethodRecord();
+        record.IsEntireMethodGeneration = true;
+        LastMethodRecord = record;
+        return new RecordingMethodBuilderStage1(record, this);
+    }
 
     public IMethodBodyGeneratorWithNoParameter CreateImplementation()
     {
@@ -38,13 +60,22 @@ public IMethodBodyGenerator<TArg1, TReturnType> CreateImplementation<TArg1, TRet
         LastRecord = record;
         return new RecordingMethodImplementationGenerator<TArg1, TReturnType>(record);
     }
+
+    internal void SetSwitchBodyFromMethod(SwitchBodyRecord record)
+    {
+        LastRecord = record;
+    }
 }
 
 public class RecordingMethodImplementationGenerator : IMethodBodyGeneratorWithNoParameter;
 
 public class RecordingMethodImplementationGeneratorTyped<TReturnType> : IMethodBodyGenerator<TReturnType>
 {
-    public IMethodBodyGeneratorWithNoParameter BodyReturningConstantValue(Func<object> body) => this;
+    public IMethodBodyGeneratorWithNoParameter BodyReturningConstantValue(Func<object> body)
+    {
+        body();
+        return new RecordingMethodImplementationGenerator();
+    }
 }
 
 public class RecordingMethodImplementationGenerator<TArg1, TReturnType>(SwitchBodyRecord record) : IMethodBodyGenerator<TArg1, TReturnType>
@@ -106,7 +137,7 @@ public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> ReturnConstantValue(Fu
         return new RecordingMethodImplementationGeneratorSwitchBody<TArg1, TReturnType>(record);
     }
 
-    public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> UseBody(Func<TArg1, Action<TReturnType>> body)
+    public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> UseProvidedBody(Func<TArg1, TReturnType> body)
     {
         foreach (TArg1? caseValue in cases)
         {
@@ -120,15 +151,284 @@ public IMethodBodyGeneratorSwitchBody<TArg1, TReturnType> UseBody(Func<TArg1, Ac
 public class RecordingMethodImplementationGeneratorSwitchBodyDefaultCase<TArg1, TReturnType>(SwitchBodyRecord record)
     : IMethodBodyGeneratorSwitchBodyDefaultCase<TArg1, TReturnType>
 {
-    public IMethodBodyGenerator<TArg1, TReturnType> ReturnConstantValue(Func<TArg1, TReturnType> func)
+    public IMethodBodyGenerator ReturnConstantValue(Func<TArg1, TReturnType> func)
     {
         record.HasDefaultCase = true;
         return new RecordingMethodImplementationGenerator<TArg1, TReturnType>(record);
     }
 
-    public IMethodBodyGenerator<TArg1, TReturnType> UseProvidedBody(Func<TArg1, Func<TReturnType>> func)
+    public IMethodBodyGenerator UseProvidedBody(Func<TArg1, TReturnType> func)
     {
         record.HasDefaultCase = true;
         return new RecordingMethodImplementationGenerator<TArg1, TReturnType>(record);
     }
 }
+
+// Recording implementations for Method builder (entire method generation)
+public class RecordingMethodBuilderStage1(MethodRecord methodRecord, RecordingGeneratorsFactory factory) : IMethodBuilderStage1
+{
+    public IMethodBuilderStage2 WithName(string name)
+    {
+        methodRecord.MethodName = name;
+        return new RecordingMethodBuilderStage2(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage2 WithName(Func<string> nameFactory)
+    {
+        methodRecord.MethodName = nameFactory();
+        return new RecordingMethodBuilderStage2(methodRecord, factory);
+    }
+}
+
+public class RecordingMethodBuilderStage2(MethodRecord methodRecord, RecordingGeneratorsFactory factory) : IMethodBuilderStage2
+{
+    public IMethodBuilderStage3ReturningVoid WithVoidReturn()
+    {
+        methodRecord.ReturnTypeName = "void";
+        return new RecordingMethodBuilderStage3ReturningVoid(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage3<TReturnType> WithReturnType<TReturnType>()
+    {
+        methodRecord.ReturnTypeName = typeof(TReturnType).FullName ?? typeof(TReturnType).Name;
+        return new RecordingMethodBuilderStage3<TReturnType>(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(Type returnType)
+    {
+        methodRecord.ReturnTypeName = returnType.FullName ?? returnType.Name;
+        return new RecordingMethodBuilderStage3WithSomeReturnType(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(string returnType)
+    {
+        methodRecord.ReturnTypeName = returnType;
+        return new RecordingMethodBuilderStage3WithSomeReturnType(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(Func<Type> returnTypeFactory)
+    {
+        Type returnType = returnTypeFactory();
+        methodRecord.ReturnTypeName = returnType.FullName ?? returnType.Name;
+        return new RecordingMethodBuilderStage3WithSomeReturnType(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage3WithSomeReturnType WithReturnType(Func<string> returnTypeFactory)
+    {
+        methodRecord.ReturnTypeName = returnTypeFactory();
+        return new RecordingMethodBuilderStage3WithSomeReturnType(methodRecord, factory);
+    }
+}
+
+public class RecordingMethodBuilderStage3ReturningVoid(MethodRecord methodRecord, RecordingGeneratorsFactory factory) : IMethodBuilderStage3ReturningVoid
+{
+    public IMethodBuilderStage4ReturnVoidNoParam WithNoParameters() =>
+        new RecordingMethodBuilderStage4ReturnVoidNoParam(methodRecord);
+
+    public IMethodBuilderStage4ReturnVoid<TParam1> WithParameter<TParam1>()
+    {
+        methodRecord.ParameterTypeNames.Add(typeof(TParam1).FullName ?? typeof(TParam1).Name);
+        return new RecordingMethodBuilderStage4ReturnVoid<TParam1>(methodRecord);
+    }
+
+    public IMethodBuilderStage4ReturnVoid WithParameter(Type param1)
+    {
+        methodRecord.ParameterTypeNames.Add(param1.FullName ?? param1.Name);
+        return new RecordingMethodBuilderStage4ReturnVoidNonGeneric(methodRecord);
+    }
+
+    public IMethodBuilderStage4ReturnVoid WithParameter(string param1)
+    {
+        methodRecord.ParameterTypeNames.Add(param1);
+        return new RecordingMethodBuilderStage4ReturnVoidNonGeneric(methodRecord);
+    }
+
+    public IMethodBuilderStage4ReturnVoid WithParameter(Func<Type> param1Factory)
+    {
+        Type param1 = param1Factory();
+        methodRecord.ParameterTypeNames.Add(param1.FullName ?? param1.Name);
+        return new RecordingMethodBuilderStage4ReturnVoidNonGeneric(methodRecord);
+    }
+
+    public IMethodBuilderStage4ReturnVoid WithParameter(Func<string> param1Factory)
+    {
+        methodRecord.ParameterTypeNames.Add(param1Factory());
+        return new RecordingMethodBuilderStage4ReturnVoidNonGeneric(methodRecord);
+    }
+}
+
+public class RecordingMethodBuilderStage3<TReturnType>(MethodRecord methodRecord, RecordingGeneratorsFactory factory) : IMethodBuilderStage3<TReturnType>
+{
+    public IMethodBuilderStage4NoParam<TReturnType> WithNoParameters() =>
+        new RecordingMethodBuilderStage4NoParam<TReturnType>(methodRecord, factory);
+
+    public IMethodBuilderStage4<TParam1, TReturnType> WithParameter<TParam1>()
+    {
+        methodRecord.ParameterTypeNames.Add(typeof(TParam1).FullName ?? typeof(TParam1).Name);
+        return new RecordingMethodBuilderStage4<TParam1, TReturnType>(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Type param1)
+    {
+        methodRecord.ParameterTypeNames.Add(param1.FullName ?? param1.Name);
+        return new RecordingMethodBuilderStage4WithSomeParam<TReturnType>(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(string param1)
+    {
+        methodRecord.ParameterTypeNames.Add(param1);
+        return new RecordingMethodBuilderStage4WithSomeParam<TReturnType>(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Func<Type> param1Factory)
+    {
+        Type param1 = param1Factory();
+        methodRecord.ParameterTypeNames.Add(param1.FullName ?? param1.Name);
+        return new RecordingMethodBuilderStage4WithSomeParam<TReturnType>(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeParam<TReturnType> WithParameter(Func<string> param1Factory)
+    {
+        methodRecord.ParameterTypeNames.Add(param1Factory());
+        return new RecordingMethodBuilderStage4WithSomeParam<TReturnType>(methodRecord, factory);
+    }
+}
+
+public class RecordingMethodBuilderStage3WithSomeReturnType(MethodRecord methodRecord, RecordingGeneratorsFactory factory) : IMethodBuilderStage3WithSomeReturnType
+{
+    public IMethodBuilderStage4WithSomeReturnTypeNoParam WithNoParameters() =>
+        new RecordingMethodBuilderStage4WithSomeReturnTypeNoParam(methodRecord, factory);
+
+    public IMethodBuilderStage4WithSomeReturnType<TParam1> WithParameter<TParam1>()
+    {
+        methodRecord.ParameterTypeNames.Add(typeof(TParam1).FullName ?? typeof(TParam1).Name);
+        return new RecordingMethodBuilderStage4WithSomeReturnType<TParam1>(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(Type param1)
+    {
+        methodRecord.ParameterTypeNames.Add(param1.FullName ?? param1.Name);
+        return new RecordingMethodBuilderStage4WithSomeReturnTypeWithSomeParam(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(string param1)
+    {
+        methodRecord.ParameterTypeNames.Add(param1);
+        return new RecordingMethodBuilderStage4WithSomeReturnTypeWithSomeParam(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(Func<Type> param1Factory)
+    {
+        Type param1 = param1Factory();
+        methodRecord.ParameterTypeNames.Add(param1.FullName ?? param1.Name);
+        return new RecordingMethodBuilderStage4WithSomeReturnTypeWithSomeParam(methodRecord, factory);
+    }
+
+    public IMethodBuilderStage4WithSomeReturnTypeWithSomeParam WithParameter(Func<string> param1Factory)
+    {
+        methodRecord.ParameterTypeNames.Add(param1Factory());
+        return new RecordingMethodBuilderStage4WithSomeReturnTypeWithSomeParam(methodRecord, factory);
+    }
+}
+
+// Stage4 recording implementations - Terminal methods
+public class RecordingMethodBuilderStage4ReturnVoidNoParam(MethodRecord methodRecord) : IMethodBuilderStage4ReturnVoidNoParam
+{
+    public IMethodBodyGenerator UseProvidedBody(Action body) => new RecordingMethodImplementationGenerator();
+}
+
+public class RecordingMethodBuilderStage4ReturnVoid<TParam1>(MethodRecord methodRecord) : IMethodBuilderStage4ReturnVoid<TParam1>
+{
+    public IMethodBodyGenerator UseProvidedBody(Action<TParam1> body) => new RecordingMethodImplementationGenerator();
+}
+
+public class RecordingMethodBuilderStage4ReturnVoidNonGeneric(MethodRecord methodRecord) : IMethodBuilderStage4ReturnVoid
+{
+    public IMethodBodyGenerator UseProvidedBody(Action<object> body) => new RecordingMethodImplementationGenerator();
+}
+
+public class RecordingMethodBuilderStage4NoParam<TReturnType>(MethodRecord methodRecord, RecordingGeneratorsFactory factory)
+    : IMethodBuilderStage4NoParam<TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TReturnType> body) => new RecordingMethodImplementationGenerator();
+
+    public IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory)
+    {
+        object? value = constantValueFactory();
+        methodRecord.ConstantValue = value;
+        return new RecordingMethodImplementationGenerator();
+    }
+}
+
+public class RecordingMethodBuilderStage4<TParam1, TReturnType>(MethodRecord methodRecord, RecordingGeneratorsFactory factory)
+    : IMethodBuilderStage4<TParam1, TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TParam1, TReturnType> body) => new RecordingMethodImplementationGenerator();
+
+    public IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory)
+    {
+        object? value = constantValueFactory();
+        methodRecord.ConstantValue = value;
+        return new RecordingMethodImplementationGenerator();
+    }
+
+    public IMethodBodyGeneratorSwitchBody<TParam1, TReturnType> BodyWithSwitchStatement()
+    {
+        SwitchBodyRecord switchRecord = new SwitchBodyRecord();
+        methodRecord.SwitchBody = switchRecord;
+        factory.SetSwitchBodyFromMethod(switchRecord);
+        return new RecordingMethodImplementationGeneratorSwitchBody<TParam1, TReturnType>(switchRecord);
+    }
+}
+
+public class RecordingMethodBuilderStage4WithSomeParam<TReturnType>(MethodRecord methodRecord, RecordingGeneratorsFactory factory)
+    : IMethodBuilderStage4WithSomeParam<TReturnType>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<object, TReturnType> body) => new RecordingMethodImplementationGenerator();
+
+    public IMethodBodyGenerator BodyReturningConstant(Func<TReturnType> constantValueFactory)
+    {
+        object? value = constantValueFactory();
+        methodRecord.ConstantValue = value;
+        return new RecordingMethodImplementationGenerator();
+    }
+}
+
+public class RecordingMethodBuilderStage4WithSomeReturnTypeNoParam(MethodRecord methodRecord, RecordingGeneratorsFactory factory)
+    : IMethodBuilderStage4WithSomeReturnTypeNoParam
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<object> body) => new RecordingMethodImplementationGenerator();
+
+    public IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory)
+    {
+        object? value = constantValueFactory();
+        methodRecord.ConstantValue = value;
+        return new RecordingMethodImplementationGenerator();
+    }
+}
+
+public class RecordingMethodBuilderStage4WithSomeReturnType<TParam1>(MethodRecord methodRecord, RecordingGeneratorsFactory factory)
+    : IMethodBuilderStage4WithSomeReturnType<TParam1>
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<TParam1, object> body) => new RecordingMethodImplementationGenerator();
+
+    public IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory)
+    {
+        object? value = constantValueFactory();
+        methodRecord.ConstantValue = value;
+        return new RecordingMethodImplementationGenerator();
+    }
+}
+
+public class RecordingMethodBuilderStage4WithSomeReturnTypeWithSomeParam(MethodRecord methodRecord, RecordingGeneratorsFactory factory)
+    : IMethodBuilderStage4WithSomeReturnTypeWithSomeParam
+{
+    public IMethodBodyGenerator UseProvidedBody(Func<object, object> body) => new RecordingMethodImplementationGenerator();
+
+    public IMethodBodyGenerator BodyReturningConstant(Func<object> constantValueFactory)
+    {
+        object? value = constantValueFactory();
+        methodRecord.ConstantValue = value;
+        return new RecordingMethodImplementationGenerator();
+    }
+}
diff --git a/EasySourceGenerators.Tests/ColorsClassFluentCreatedTests.cs b/EasySourceGenerators.Tests/ColorsClassFluentCreatedTests.cs
new file mode 100644
index 0000000..1c82973
--- /dev/null
+++ b/EasySourceGenerators.Tests/ColorsClassFluentCreatedTests.cs
@@ -0,0 +1,47 @@
+using EasySourceGenerators.Abstractions;
+
+namespace EasySourceGenerators.Tests;
+
+[TestFixture]
+public class ColorsClassFluentCreatedTests
+{
+    [Test]
+    public void ColorsClassFluentCreated_ProducesExpectedRuntimeOutput()
+    {
+        TestColorsClassFluentCreated testColorsClass = new TestColorsClassFluentCreated();
+
+        string allColors = testColorsClass.GetAllColorsString();
+
+        Assert.That(allColors, Is.EqualTo("Red, Green, Blue"));
+    }
+
+    [Test]
+    public void ColorsClassFluentCreated_ProducesExpectedGeneratedCode()
+    {
+        string generatedCode = GeneratedCodeTestHelper.ReadGeneratedCode("TestColorsClassFluentCreated_GetAllColorsString.g.cs");
+        string expectedCode = """
+                              namespace EasySourceGenerators.Tests;
+
+                              partial class TestColorsClassFluentCreated
+                              {
+                                  public System.String GetAllColorsString()
+                                  {
+                                      return "Red, Green, Blue";
+                                  }
+                              }
+                              """.ReplaceLineEndings("\n").TrimEnd();
+
+        Assert.That(generatedCode, Is.EqualTo(expectedCode));
+    }
+}
+
+public partial class TestColorsClassFluentCreated
+{
+    [MethodBodyGenerator("GetAllColorsString")]
+    static IMethodBodyGenerator GetAllColorsString_Generator() =>
+        Generate.Method()
+            .WithName("GetAllColorsString")
+            .WithReturnType<string>()
+            .WithNoParameters()
+            .BodyReturningConstant(() => string.Join(", ", Enum.GetNames<TestColorsEnum>()));
+}
diff --git a/EasySourceGenerators.Tests/MapperFluentCreatedTests.cs b/EasySourceGenerators.Tests/MapperFluentCreatedTests.cs
new file mode 100644
index 0000000..d8527a6
--- /dev/null
+++ b/EasySourceGenerators.Tests/MapperFluentCreatedTests.cs
@@ -0,0 +1,68 @@
+using EasySourceGenerators.Abstractions;
+
+namespace EasySourceGenerators.Tests;
+
+[TestFixture]
+public class MapperFluentCreatedTests
+{
+    [TestCase(TestFourLeggedAnimal.Dog, TestMammalAnimal.Dog)]
+    [TestCase(TestFourLeggedAnimal.Cat, TestMammalAnimal.Cat)]
+    public void MapperFluentCreated_ProducesExpectedRuntimeOutput(TestFourLeggedAnimal source, TestMammalAnimal expected)
+    {
+        TestMapperFluentCreated mapper = new TestMapperFluentCreated();
+
+        TestMammalAnimal result = mapper.MapToMammal(source);
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void MapperFluentCreated_ThrowsForUnmappableValue()
+    {
+        TestMapperFluentCreated mapper = new TestMapperFluentCreated();
+
+        Assert.Throws<ArgumentException>(() => mapper.MapToMammal(TestFourLeggedAnimal.Lizard));
+    }
+
+    [Test]
+    public void MapperFluentCreated_ProducesExpectedGeneratedCode()
+    {
+        string generatedCode = GeneratedCodeTestHelper.ReadGeneratedCode("TestMapperFluentCreated_MapToMammal.g.cs");
+        string expectedCode = """
+                              namespace EasySourceGenerators.Tests;
+
+                              partial class TestMapperFluentCreated
+                              {
+                                  public EasySourceGenerators.Tests.TestMammalAnimal MapToMammal(EasySourceGenerators.Tests.TestFourLeggedAnimal fourLeggedAnimal)
+                                  {
+                                      switch (fourLeggedAnimal)
+                                      {
+                                          case EasySourceGenerators.Tests.TestFourLeggedAnimal.Dog: return EasySourceGenerators.Tests.TestMammalAnimal.Dog;
+                                          case EasySourceGenerators.Tests.TestFourLeggedAnimal.Cat: return EasySourceGenerators.Tests.TestMammalAnimal.Cat;
+                                          default: throw new ArgumentException($"Cannot map {fourLeggedAnimal} to a Mammal");
+                                      }
+                                  }
+                              }
+                              """.ReplaceLineEndings("\n").TrimEnd();
+
+        Assert.That(generatedCode, Is.EqualTo(expectedCode));
+    }
+}
+
+public partial class TestMapperFluentCreated
+{
+    [MethodBodyGenerator("MapToMammal")]
+    static IMethodBodyGenerator MapToMammal_Generator() =>
+        Generate.Method()
+            .WithName("MapToMammal")
+            .WithReturnType<TestMammalAnimal>()
+            .WithParameter<TestFourLeggedAnimal>()
+            .BodyWithSwitchStatement()
+            .ForCases(GetFourLeggedAnimalsThatAreAlsoMammal()).ReturnConstantValue(a => Enum.Parse<TestMammalAnimal>(a.ToString(), true))
+            .ForDefaultCase().UseProvidedBody(fourLeggedAnimal => throw new ArgumentException($"Cannot map {fourLeggedAnimal} to a Mammal"));
+
+    static TestFourLeggedAnimal[] GetFourLeggedAnimalsThatAreAlsoMammal() =>
+        Enum.GetValues<TestFourLeggedAnimal>()
+            .Where(a => Enum.TryParse(typeof(TestMammalAnimal), a.ToString(), true, out _))
+            .ToArray();
+}
diff --git a/EasySourceGenerators.Tests/PiExampleFluentTests.cs b/EasySourceGenerators.Tests/PiExampleFluentTests.cs
index d26b339..dcb5c9d 100644
--- a/EasySourceGenerators.Tests/PiExampleFluentTests.cs
+++ b/EasySourceGenerators.Tests/PiExampleFluentTests.cs
@@ -137,7 +137,7 @@ static IMethodBodyGenerator MapToMammal_Generator() =>
             .MethodBody().WithParameter<TestFourLeggedAnimal>().WithReturnType<TestMammalAnimal>()
             .GenerateSwitchBody()
             .ForCases(GetFourLeggedAnimalsThatAreAlsoMammal()).ReturnConstantValue(a => Enum.Parse<TestMammalAnimal>(a.ToString(), true))
-            .ForDefaultCase().UseBody(fourLeggedAnimal => () => throw new ArgumentException($"Cannot map {fourLeggedAnimal} to a mammal"));
+            .ForDefaultCase().UseProvidedBody(fourLeggedAnimal => throw new ArgumentException($"Cannot map {fourLeggedAnimal} to a mammal"));
 
     static TestFourLeggedAnimal[] GetFourLeggedAnimalsThatAreAlsoMammal() =>
         Enum.GetValues<TestFourLeggedAnimal>()
@@ -155,7 +155,7 @@ static IMethodBodyGenerator GetPiDecimal_Generator() =>
             .MethodBody().WithParameter<int>().WithReturnType<int>()
             .GenerateSwitchBody()
             .ForCases(0, 1, 2, new[]{300, 301, 302, 303}).ReturnConstantValue(decimalNumber => TestSlowMath.CalculatePiDecimal(decimalNumber))
-            .ForDefaultCase().UseBody(decimalNumber => () => TestSlowMath.CalculatePiDecimal(decimalNumber));
+            .ForDefaultCase().UseProvidedBody(decimalNumber => TestSlowMath.CalculatePiDecimal(decimalNumber));
 }
 
 public static partial class TestMapperFluent
@@ -169,5 +169,5 @@ static IMethodBodyGenerator MapToMammal_Generator() =>
             .GenerateSwitchBody()
             .ForCases(1).ReturnConstantValue(_ => "Dog")
             .ForCases(2).ReturnConstantValue(_ => "Cat")
-            .ForDefaultCase().UseBody(_ => () => "Unknown");
+            .ForDefaultCase().UseProvidedBody(_ => "Unknown");
 }