From 8b39986ac2032839fb6318d72312f4cead458170 Mon Sep 17 00:00:00 2001
From: Igor Sinicyn <igor.sinicyn@gmail.com>
Date: Thu, 20 Aug 2026 21:44:55 +0300
Subject: [PATCH] ScaffoldCS.Templates

---
 .editorconfig                                 |   7 +
 CodeMe.ScaffoldCS.sln.DotSettings             |   6 +
 CodeMe.ScaffoldCS.slnx                        |   2 +
 Directory.Packages.props                      |   3 +-
 README.md                                     |  30 +
 docs/TemplateRender.md                        |   9 +
 .../CodeMe.ScaffoldCS.Templates.csproj        |  14 +
 .../Infrastructure/CharSpanExtensions.cs      |  20 +
 .../Internals/AmbientTemplate.cs              |  16 +
 .../Internals/ConditionBranch.cs              |   9 +
 .../Internals/IControlTemplateSymbol.cs       |   5 +
 .../Internals/IScopedTemplateValue.cs         |   6 +
 .../Internals/ITemplatePart.cs                |  24 +
 .../Internals/ITemplateSymbol.cs              |   6 +
 .../Output/CurrentLineHandlingMode.cs         |  12 +
 .../Output/CurrentLineState.cs                |  14 +
 .../Output/IndentationFormat.cs               |  14 +
 .../Output/NewLineFormat.cs                   |  12 +
 .../Output/TemplateTextWriter.cs              | 438 ++++++++
 .../Output/TemplateTextWriterOptions.cs       |  22 +
 .../Render/ClearLineSymbol.cs                 |   8 +
 .../Render/CollectionRenderExtensions.cs      |  26 +
 .../Render/CollectionRenderOptions.cs         |  21 +
 .../Render/CollectionSymbol.cs                |  45 +
 .../Render/ConditionBranchSymbol.cs           |  44 +
 .../Render/ConditionSymbol`1.cs               |  17 +
 .../Render/ConditionSymbol`2.cs               |  22 +
 .../Render/Conditions.cs                      |  37 +
 .../Render/IfFalseTemplatePart.cs             |  68 ++
 .../Render/IfTrueTemplatePart.cs              |  68 ++
 .../Render/LineHandlingSymbol.cs              |   9 +
 .../Render/Symbols.cs                         |  62 ++
 .../Render/SymbolsCS.cs                       |  55 +
 .../Render/ValueSymbol.cs                     |  19 +
 .../Template.Context.cs                       | 115 ++
 .../Template.TestAccessor.cs                  |  21 +
 .../Template.Write.cs                         | 319 ++++++
 src/CodeMe.ScaffoldCS.Templates/Template.cs   |  56 +
 .../TemplatePart.cs                           |  56 +
 .../packages.lock.json                        |  13 +
 .../CodeMe.ScaffoldCS.csproj                  |   4 +
 src/CodeMe.ScaffoldCS/README.md               |   2 +-
 src/CodeMe.ScaffoldCS/packages.lock.json      |  15 +-
 ...deMe.ScaffoldCS.Templates.UnitTests.csproj |   7 +
 .../Infrastructure/Models/Class.cs            |   3 +
 .../Infrastructure/Models/Property.cs         |   3 +
 .../Infrastructure/TemplateTestExtensions.cs  |  30 +
 .../TemplateTextWriterTestExtensions.cs       |  75 ++
 .../Output/TemplateTextWriterTests.cs         | 997 ++++++++++++++++++
 .../TemplateTests.cs                          | 350 ++++++
 .../packages.lock.json                        | 154 +++
 .../TemplateTests.cs                          |  11 +
 .../packages.lock.json                        | 105 +-
 53 files changed, 3461 insertions(+), 45 deletions(-)
 create mode 100644 docs/TemplateRender.md
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/CodeMe.ScaffoldCS.Templates.csproj
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Infrastructure/CharSpanExtensions.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Internals/AmbientTemplate.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Internals/ConditionBranch.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Internals/IControlTemplateSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Internals/IScopedTemplateValue.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Internals/ITemplatePart.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Internals/ITemplateSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineHandlingMode.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineState.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Output/IndentationFormat.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Output/NewLineFormat.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriter.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriterOptions.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/ClearLineSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderExtensions.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderOptions.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/CollectionSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/ConditionBranchSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`1.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`2.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/Conditions.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/IfFalseTemplatePart.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/IfTrueTemplatePart.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/LineHandlingSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/Symbols.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/SymbolsCS.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Render/ValueSymbol.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Template.Context.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Template.TestAccessor.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Template.Write.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/Template.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/TemplatePart.cs
 create mode 100644 src/CodeMe.ScaffoldCS.Templates/packages.lock.json
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/CodeMe.ScaffoldCS.Templates.UnitTests.csproj
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Class.cs
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Property.cs
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTestExtensions.cs
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTextWriterTestExtensions.cs
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/Output/TemplateTextWriterTests.cs
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/TemplateTests.cs
 create mode 100644 tests/CodeMe.ScaffoldCS.Templates.UnitTests/packages.lock.json
 create mode 100644 tests/CodeMe.ScaffoldCS.UnitTests/TemplateTests.cs

diff --git a/.editorconfig b/.editorconfig
index 1e10e86..2ed42e2 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,18 +1,25 @@
 [*.cs]
 csharp_style_prefer_primary_constructors = false
 dotnet_style_prefer_collection_expression = false
+csharp_indent_braces = false
+csharp_new_line_before_open_brace = all
 
 # ReSharper properties
 resharper_align_multiline_binary_expressions_chain = false
 resharper_braces_for_foreach = required
 resharper_braces_for_ifelse = required
 resharper_braces_for_while = required
+resharper_braces_redundant = true
 resharper_csharp_keep_blank_lines_in_code = 1
 resharper_csharp_keep_blank_lines_in_declarations = 1
 resharper_csharp_wrap_before_binary_opsign = true
 resharper_csharp_wrap_parameters_style = chop_if_long
+resharper_max_attribute_length_for_same_line = 60
 resharper_method_or_operator_body = expression_body
 resharper_place_single_method_argument_lambda_on_same_line = false
 resharper_wrap_after_declaration_lpar = true
 resharper_wrap_after_invocation_lpar = true
 resharper_wrap_chained_binary_expressions = chop_if_long
+
+# Microsoft .NET properties
+csharp_prefer_braces = true:none
diff --git a/CodeMe.ScaffoldCS.sln.DotSettings b/CodeMe.ScaffoldCS.sln.DotSettings
index ed3bda4..8d9d380 100644
--- a/CodeMe.ScaffoldCS.sln.DotSettings
+++ b/CodeMe.ScaffoldCS.sln.DotSettings
@@ -5,9 +5,15 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeCleanup/CleanupOnSave/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=Cleanup_0020on_0020Save/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="Cleanup on Save"&gt;&lt;CSCodeStyleAttributes ArrangeVarStyle="True" ArrangeTypeAccessModifier="True" ArrangeTypeMemberAccessModifier="True" SortModifiers="True" ArrangeAccessors="True" RemoveRedundantParentheses="True" AddMissingParentheses="True" ArrangeAttributes="True" ArrangeCodeBodyStyle="True" ArrangeTrailingCommas="True" ArrangeObjectCreation="True" ArrangeDefaultValue="True" ArrangeEmptyString="True" ArrangeNamespaces="True" ArrangeNullCheckingPattern="True" ArrangeBraces="True" /&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSFixBuiltinTypeReferences&gt;True&lt;/CSFixBuiltinTypeReferences&gt;&lt;XMLReformatCode&gt;True&lt;/XMLReformatCode&gt;&lt;CSMakeFieldReadonly&gt;True&lt;/CSMakeFieldReadonly&gt;&lt;CSMakeAutoPropertyGetOnly&gt;True&lt;/CSMakeAutoPropertyGetOnly&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;/CSOptimizeUsings&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSharpFormatDocComments&gt;True&lt;/CSharpFormatDocComments&gt;&lt;CSharpReformatComments&gt;True&lt;/CSharpReformatComments&gt;&lt;XAMLCollapseEmptyTags&gt;False&lt;/XAMLCollapseEmptyTags&gt;&lt;RemoveCodeRedundancies&gt;True&lt;/RemoveCodeRedundancies&gt;&lt;/Profile&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_IFELSE/@EntryValue">Required</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_RAW_LITERAL_STRING/@EntryValue">DO_NOT_CHANGE</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INT_ALIGN_FIX_IN_ADJACENT/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/XmlDocFormatter/IndentTagContent/@EntryValue">ZeroIndent</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/XmlDocFormatter/TagSpaceBeforeHeaderEnd1/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=15b5b1f1_002D457c_002D4ca6_002Db278_002D5615aedc07d3/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static readonly fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpUseContinuousIndentInsideBracesMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EUnitTestFramework_002EMigrations_002EEnableDisabledProvidersMigration/@EntryIndexedValue">True</s:Boolean>
 	
 </wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/CodeMe.ScaffoldCS.slnx b/CodeMe.ScaffoldCS.slnx
index 76332cd..ea37f3d 100644
--- a/CodeMe.ScaffoldCS.slnx
+++ b/CodeMe.ScaffoldCS.slnx
@@ -7,9 +7,11 @@
     <Project Path="env/env.csproj" />
   </Folder>
   <Folder Name="/src/">
+    <Project Path="src/CodeMe.ScaffoldCS.Templates/CodeMe.ScaffoldCS.Templates.csproj" />
     <Project Path="src/CodeMe.ScaffoldCS/CodeMe.ScaffoldCS.csproj" />
   </Folder>
   <Folder Name="/tests/">
+    <Project Path="tests/CodeMe.ScaffoldCS.Templates.UnitTests/CodeMe.ScaffoldCS.Templates.UnitTests.csproj" Id="530fdd6f-e3f6-46b3-bdd8-110ee57c9ca7" />
     <Project Path="tests/CodeMe.ScaffoldCS.UnitTests/CodeMe.ScaffoldCS.UnitTests.csproj" />
   </Folder>
 </Solution>
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 6d54c12..b889258 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -4,7 +4,8 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="AwesomeAssertions" Version="9.5.0" />
+    <PackageVersion Include="CodeMe.Basics" Version="0.0.3" />
     <PackageVersion Include="Microsoft.Testing.Extensions.TrxReport" Version="2.3.3" />
-    <PackageVersion Include="xunit.v3.mtp-v2" Version="3.2.2" />
+    <PackageVersion Include="xunit.v3.mtp-v2" Version="4.0.1" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/README.md b/README.md
index 1c2b6d1..ad8bada 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,32 @@
 # CodeMe.ScaffoldCS
 Scaffolding framework inspired by CodegenCS
+
+# Template issues
+
+Have a good scenarios:
+* Last line behavior (last line is empty)
+  * May be fixed if we keep endline in the current line and trim endline on close
+    (last line behavior)
+  * Will also fix inconsistency with delayed flush on MacOS ('\r' separator)
+* Consider to split Template and advanced rendering logic. The goal is to have api that allows to add third-party rendering customisation
+* Add api for column-level padding. Func to PaddedTemplatePart?
+  * Need both options.
+* Split template / text writer options
+
+Waits for grooming:
+* Value handling customizations. Interceptors?
+  * We need a really good scenario for it. With naive implementation interceptors will slow down each write operation so lets keep it on hold.
+* Review behaviors for `// {SummaryWithNewLineAtTheEnd} something` render scenario. Something like NextLineIndentation or EnforceIndentation() maybe?
+* Shall we append indentation on whitespace-only lines?
+  * Do we need "append indentation on empty lines" option?
+* Add support for alignment arg for multiline values?
+  * Need a good scenario for this. We have auto-indentation for this
+* Multiline value nahdling.
+  * Add option for Template to disable multiline indentation. Add .RenderLiteral() / .RenderMultiline()
+  * Or just add .RenderLiteral() and no option
+
+Delayed:
+* Docs are missing
+* No XML comments
+
+# Metamodel issues
\ No newline at end of file
diff --git a/docs/TemplateRender.md b/docs/TemplateRender.md
new file mode 100644
index 0000000..294acd1
--- /dev/null
+++ b/docs/TemplateRender.md
@@ -0,0 +1,9 @@
+# Summary
+
+Render logic is based on c# [interpolated dtring handler](https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/performance/interpolated-string-handler) feature.
+
+Also, we use ambient template context (based on [ScopedAsyncLocal&lt;T&gt;](https://github.com/ig-sinicyn/CodeMe/tree/master/docs/Basics/AsyncLocal)) to ease passing of the current writer to the nested parts.
+
+We do support conditional evaluation by IIF/IF-ELSE-ENDIF macro.
+
+We do support conditional line trim by RL (RemoveLine macro)
diff --git a/src/CodeMe.ScaffoldCS.Templates/CodeMe.ScaffoldCS.Templates.csproj b/src/CodeMe.ScaffoldCS.Templates/CodeMe.ScaffoldCS.Templates.csproj
new file mode 100644
index 0000000..50c7988
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/CodeMe.ScaffoldCS.Templates.csproj
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+
+	<PropertyGroup>
+		<TargetFramework>net10.0</TargetFramework>
+		<Description>Template render engine inspired by CodegenCS</Description>
+		<PackageTags>Scaffolld;Template;Codegen;Code Generation</PackageTags>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="CodeMe.Basics" />
+	</ItemGroup>
+
+</Project>
diff --git a/src/CodeMe.ScaffoldCS.Templates/Infrastructure/CharSpanExtensions.cs b/src/CodeMe.ScaffoldCS.Templates/Infrastructure/CharSpanExtensions.cs
new file mode 100644
index 0000000..c29934b
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Infrastructure/CharSpanExtensions.cs
@@ -0,0 +1,20 @@
+namespace CodeMe.ScaffoldCS.Templates.Infrastructure;
+
+internal static class CharSpanExtensions
+{
+    public static int NextIndexOfAny(
+        this ReadOnlySpan<char> span,
+        int startIndex,
+        char value0,
+        char value1)
+    {
+        var index = span[startIndex..].IndexOfAny(value0, value1);
+        return index < 0 ? index : startIndex + index;
+    }
+
+    public static bool IsMultiline(this ReadOnlySpan<char> span)
+    {
+        var index = span.IndexOfAny('\r', '\n');
+        return index >= 0;
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Internals/AmbientTemplate.cs b/src/CodeMe.ScaffoldCS.Templates/Internals/AmbientTemplate.cs
new file mode 100644
index 0000000..6bb04d6
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Internals/AmbientTemplate.cs
@@ -0,0 +1,16 @@
+using CodeMe.Basics.Threading;
+
+namespace CodeMe.ScaffoldCS.Templates.Internals;
+
+public static class AmbientTemplate
+{
+    private static readonly ScopedAsyncLocal<Template> _templateStack = new();
+
+    internal static IDisposable BeginTemplateScope(Template context) => _templateStack.BeginScope(context);
+
+    public static Template Current => _templateStack.Current
+        ?? throw new InvalidOperationException(
+            $"There is no ambient template. Call {nameof(Template)}.{nameof(Template.BeginAmbientScope)} to enable ambient templates");
+
+    public static Template? CurrentOrDefault => _templateStack.Current;
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Internals/ConditionBranch.cs b/src/CodeMe.ScaffoldCS.Templates/Internals/ConditionBranch.cs
new file mode 100644
index 0000000..470d22b
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Internals/ConditionBranch.cs
@@ -0,0 +1,9 @@
+namespace CodeMe.ScaffoldCS.Templates.Internals;
+
+public enum ConditionBranch
+{
+    None,
+    IfBranch,
+    ElseIfBranch,
+    ElseBranch
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Internals/IControlTemplateSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Internals/IControlTemplateSymbol.cs
new file mode 100644
index 0000000..1588ef9
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Internals/IControlTemplateSymbol.cs
@@ -0,0 +1,5 @@
+namespace CodeMe.ScaffoldCS.Templates.Internals;
+
+public interface IControlTemplateSymbol : ITemplateSymbol
+{
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Internals/IScopedTemplateValue.cs b/src/CodeMe.ScaffoldCS.Templates/Internals/IScopedTemplateValue.cs
new file mode 100644
index 0000000..0ac64e1
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Internals/IScopedTemplateValue.cs
@@ -0,0 +1,6 @@
+namespace CodeMe.ScaffoldCS.Templates.Internals;
+
+public interface ITemplateScope
+{
+    void DisposeIfSame(Template caller);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Internals/ITemplatePart.cs b/src/CodeMe.ScaffoldCS.Templates/Internals/ITemplatePart.cs
new file mode 100644
index 0000000..0f2589b
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Internals/ITemplatePart.cs
@@ -0,0 +1,24 @@
+namespace CodeMe.ScaffoldCS.Templates.Internals;
+
+public interface ITemplatePart : ITemplateScope
+{
+    void AppendLiteral(string? value);
+
+    void AppendFormatted<T>(T? value);
+
+    void AppendFormatted<T>(T? value, int alignment);
+
+    void AppendFormatted<T>(T? value, int alignment, string? format);
+
+    void AppendFormatted<T>(T? value, string? format);
+
+    void AppendFormatted(string? value);
+
+    void AppendFormatted(string? value, int alignment);
+
+    void AppendFormatted(Action<Template> callback);
+
+    void AppendFormatted(Func<TemplatePart> callback);
+
+    void AppendFormatted<T>(IEnumerable<T> values);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Internals/ITemplateSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Internals/ITemplateSymbol.cs
new file mode 100644
index 0000000..026623a
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Internals/ITemplateSymbol.cs
@@ -0,0 +1,6 @@
+namespace CodeMe.ScaffoldCS.Templates.Internals;
+
+public interface ITemplateSymbol
+{
+    void Render(Template template);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineHandlingMode.cs b/src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineHandlingMode.cs
new file mode 100644
index 0000000..781ab46
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineHandlingMode.cs
@@ -0,0 +1,12 @@
+namespace CodeMe.ScaffoldCS.Templates.Output;
+
+public enum CurrentLineHandlingMode
+{
+    Normal,
+
+    IgnoreIfEmpty,
+
+    IgnoreIfWhiteSpace,
+
+    Ignore
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineState.cs b/src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineState.cs
new file mode 100644
index 0000000..ae4ca0e
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Output/CurrentLineState.cs
@@ -0,0 +1,14 @@
+namespace CodeMe.ScaffoldCS.Templates.Output;
+
+internal enum CurrentLineState
+{
+    Empty,
+
+    ValueAppended,
+
+    CrAppended,
+
+    LfAppended,
+
+    Closed
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Output/IndentationFormat.cs b/src/CodeMe.ScaffoldCS.Templates/Output/IndentationFormat.cs
new file mode 100644
index 0000000..ea9808b
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Output/IndentationFormat.cs
@@ -0,0 +1,14 @@
+namespace CodeMe.ScaffoldCS.Templates.Output;
+
+public enum IndentationFormat
+{
+    CurrentLine,
+
+    CurrentLineWhitespace,
+
+    CurrentIndentation,
+
+    IncreasedIndentation,
+
+    Empty
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Output/NewLineFormat.cs b/src/CodeMe.ScaffoldCS.Templates/Output/NewLineFormat.cs
new file mode 100644
index 0000000..2353b81
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Output/NewLineFormat.cs
@@ -0,0 +1,12 @@
+namespace CodeMe.ScaffoldCS.Templates.Output;
+
+public enum NewLineFormat
+{
+    Auto,
+
+    CrLf,
+
+    Lf,
+
+    Cr
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriter.cs b/src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriter.cs
new file mode 100644
index 0000000..d9e0af8
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriter.cs
@@ -0,0 +1,438 @@
+using System.Text;
+using CodeMe.ScaffoldCS.Templates.Infrastructure;
+
+namespace CodeMe.ScaffoldCS.Templates.Output;
+
+internal sealed class TemplateTextWriter : IDisposable
+{
+    private readonly TextWriter _output;
+    private readonly bool _leaveOutputOpen;
+    private readonly StringBuilder _currentLine;
+    private StringBuilder.AppendInterpolatedStringHandler _currentLineFormatter;
+    private CurrentLineState _currentLineState;
+    private CurrentLineHandlingMode _currentLineHandlingMode;
+
+    public TemplateTextWriter(TextWriter output, TemplateTextWriterOptions? options = null, bool leaveOpen = false)
+    {
+        _output = output;
+        _leaveOutputOpen = leaveOpen;
+        _currentLine = new StringBuilder();
+        Options = options ?? TemplateTextWriterOptions.Default;
+    }
+
+    public TemplateTextWriterOptions Options
+    {
+        get;
+        set
+        {
+            var cultureChanged = !ReferenceEquals(value.Culture, field?.Culture);
+            field = value;
+            if (cultureChanged)
+            {
+                InitFormatter();
+            }
+        }
+    }
+
+    private void InitFormatter() =>
+        _currentLineFormatter = new StringBuilder.AppendInterpolatedStringHandler(0, 0, _currentLine, Options.Culture);
+
+    public ReadOnlyMemory<char> GetCurrentLineIndentation(IndentationFormat format)
+    {
+        if (format == IndentationFormat.Empty)
+        {
+            return Array.Empty<char>();
+        }
+
+        if (format == IndentationFormat.CurrentIndentation || _currentLineState != CurrentLineState.ValueAppended)
+        {
+            return Options.Indentation;
+        }
+
+        if (format == IndentationFormat.IncreasedIndentation || _currentLineState != CurrentLineState.ValueAppended)
+        {
+            return string.Concat(Options.Indentation.Span, Options.SingleIndentation.Span).AsMemory();
+        }
+
+        var result = new char[_currentLine.Length];
+        _currentLine.CopyTo(0, result, _currentLine.Length);
+
+        if (format == IndentationFormat.CurrentLineWhitespace)
+        {
+            for (var i = 0; i < result.Length; i++)
+            {
+                if (!char.IsWhiteSpace(result[i]))
+                {
+                    result[i] = ' ';
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public TemplateTextWriter SetCurrentLineHandling(CurrentLineHandlingMode lineHandling)
+    {
+        _currentLineHandlingMode = lineHandling;
+        return this;
+    }
+
+    public TemplateTextWriter ClearLine()
+    {
+        ClearLineCore();
+        return this;
+    }
+
+    public TemplateTextWriter Append<T>(T? value)
+    {
+        if (value is null)
+        {
+            return AppendCore([]);
+        }
+
+        if (value is string @string)
+        {
+            return AppendCore(@string);
+        }
+
+        if (value is ReadOnlyMemory<char> memory)
+        {
+            return AppendCore(memory.Span);
+        }
+
+        BeforeAppend(CurrentLineState.ValueAppended);
+        _currentLineFormatter.AppendFormatted(value);
+        AfterAppend(CurrentLineState.ValueAppended);
+
+        return this;
+    }
+
+    public TemplateTextWriter Append<T>(T? value, int alignment, string? format)
+    {
+        if (value is null)
+        {
+            return AppendCore([], alignment);
+        }
+
+        if (value is string @string)
+        {
+            return AppendCore(@string, alignment);
+        }
+
+        if (value is ReadOnlyMemory<char> memory)
+        {
+            return AppendCore(memory.Span, alignment);
+        }
+
+        BeforeAppend(CurrentLineState.ValueAppended);
+        _currentLineFormatter.AppendFormatted(value, alignment, format);
+        AfterAppend(CurrentLineState.ValueAppended);
+
+        return this;
+    }
+
+    public TemplateTextWriter AppendLine() =>
+        AppendCore(GetNewLine());
+
+    public TemplateTextWriter Append(string? value) =>
+        AppendCore(value);
+
+    public TemplateTextWriter Append(string? value, int alignment) =>
+        AppendCore(value, alignment);
+
+    public TemplateTextWriter Append(ReadOnlyMemory<char> value) =>
+        AppendCore(value.Span);
+
+    public TemplateTextWriter Append(ReadOnlyMemory<char> value, int alignment) =>
+        AppendCore(value.Span, alignment);
+
+    public TemplateTextWriter Append(ReadOnlySpan<char> value) =>
+        AppendCore(value);
+
+    public TemplateTextWriter Append(ReadOnlySpan<char> value, int alignment) =>
+        AppendCore(value, alignment);
+
+    private TemplateTextWriter AppendCore(ReadOnlySpan<char> value, int alignment)
+    {
+        // Align to right. Newlines are ignored.
+        if (alignment > value.Length)
+        {
+            BeforeAppend(CurrentLineState.ValueAppended);
+            _currentLine.Append(' ', alignment - value.Length);
+            AfterAppend(CurrentLineState.ValueAppended);
+        }
+
+        // Append value with newline handling.
+        AppendCore(value);
+
+        // Align to left. Newlines are ignored
+        if (-alignment > value.Length)
+        {
+            BeforeAppend(CurrentLineState.ValueAppended);
+            _currentLine.Append(' ', -alignment - value.Length);
+            AfterAppend(CurrentLineState.ValueAppended);
+        }
+
+        return this;
+    }
+
+    private TemplateTextWriter AppendCore(ReadOnlySpan<char> value)
+    {
+        if (value.IsEmpty)
+        {
+            return this;
+        }
+
+        var index = 0;
+        while (index < value.Length)
+        {
+            switch (value[index])
+            {
+                case '\r':
+                    BeforeAppend(CurrentLineState.CrAppended);
+                    _currentLine.Append(value[index]);
+                    index++;
+                    AfterAppend(CurrentLineState.CrAppended);
+                    break;
+
+                case '\n':
+                    BeforeAppend(CurrentLineState.LfAppended);
+                    _currentLine.Append(value[index]);
+                    index++;
+                    AfterAppend(CurrentLineState.LfAppended);
+                    break;
+
+                default:
+                    BeforeAppend(CurrentLineState.ValueAppended);
+                    var lineEndIndex = value.NextIndexOfAny(index, '\r', '\n');
+                    var nextIndex = lineEndIndex < 0 ? value.Length : lineEndIndex;
+                    _currentLine.Append(value[index..nextIndex]);
+                    index = nextIndex;
+                    AfterAppend(CurrentLineState.ValueAppended);
+                    break;
+            }
+        }
+
+        return this;
+    }
+
+    public void Close()
+    {
+        if (_currentLineState == CurrentLineState.Closed)
+        {
+            return;
+        }
+
+        BeforeClose();
+        if (!_leaveOutputOpen)
+        {
+            _output.Dispose();
+        }
+
+        AfterClose();
+    }
+
+    public void Dispose() => Close();
+
+    private void BeforeAppend(CurrentLineState nextLineState)
+    {
+        AssertNotClosed();
+
+        if (_currentLineState is CurrentLineState.CrAppended && nextLineState is not CurrentLineState.LfAppended)
+        {
+            NormalizeCurrentLineEnd();
+            FlushCoreAndResetState();
+        }
+
+        var indentation = Options.Indentation;
+        if (_currentLineState is CurrentLineState.Empty && !indentation.IsEmpty)
+        {
+            if (nextLineState == CurrentLineState.ValueAppended)
+            {
+                _currentLine.Append(indentation);
+                _currentLineState = CurrentLineState.ValueAppended;
+            }
+
+            if (nextLineState is CurrentLineState.CrAppended or CurrentLineState.LfAppended
+                && Options.AppendIndentationOnEmptyLines)
+            {
+                _currentLine.Append(indentation);
+                _currentLineState = CurrentLineState.ValueAppended;
+            }
+        }
+
+        if (_currentLineState is CurrentLineState.ValueAppended
+            && nextLineState is CurrentLineState.CrAppended or CurrentLineState.LfAppended)
+        {
+            TrimCurrentLineEnd();
+        }
+    }
+
+    private void AfterAppend(CurrentLineState nextLineState)
+    {
+        if (nextLineState is CurrentLineState.LfAppended)
+        {
+            NormalizeCurrentLineEnd();
+            FlushCoreAndResetState();
+        }
+        else
+        {
+            _currentLineState = nextLineState;
+        }
+    }
+
+    private void BeforeClose()
+    {
+        AssertNotClosed();
+
+        if (_currentLineState is CurrentLineState.CrAppended or CurrentLineState.LfAppended)
+        {
+            NormalizeCurrentLineEnd();
+        }
+
+        if (_currentLineState is CurrentLineState.ValueAppended)
+        {
+            TrimCurrentLineEnd();
+        }
+
+        FlushCoreAndResetState();
+    }
+
+    private void AfterClose() => _currentLineState = CurrentLineState.Closed;
+
+    private void ClearLineCore()
+    {
+        AssertNotClosed();
+
+        if (_currentLineState is CurrentLineState.ValueAppended)
+        {
+            _currentLine.Clear();
+            _currentLineState = CurrentLineState.Empty;
+        }
+    }
+
+    private void AssertNotClosed()
+    {
+        if (_currentLineState == CurrentLineState.Closed)
+        {
+            throw new ObjectDisposedException("Cannot append text to closed template");
+        }
+    }
+
+    private string GetNewLine() =>
+        Options.NewLineFormat switch
+        {
+            NewLineFormat.Auto => Environment.NewLine,
+            NewLineFormat.CrLf => "\r\n",
+            NewLineFormat.Lf => "\n",
+            NewLineFormat.Cr => "\r",
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+    private void TrimCurrentLineEnd()
+    {
+        if (!Options.TrimLineEnd)
+        {
+            return;
+        }
+
+        var newLength = 0;
+        for (var i = _currentLine.Length - 1; i >= 0; i--)
+        {
+            if (!char.IsWhiteSpace(_currentLine[i]))
+            {
+                newLength = i + 1;
+                break;
+            }
+        }
+
+        if (_currentLine.Length != newLength)
+        {
+            _currentLine.Length = newLength;
+        }
+    }
+
+    private void NormalizeCurrentLineEnd()
+    {
+        if (!Options.NormalizeNewLines)
+        {
+            return;
+        }
+
+        switch (_currentLine)
+        {
+            case [.., '\r', '\n']:
+                _currentLine.Length -= 2;
+                _currentLine.Append(GetNewLine());
+                break;
+            case [.., '\r']:
+                _currentLine.Length -= 1;
+                _currentLine.Append(GetNewLine());
+                break;
+            case [.., '\n']:
+                _currentLine.Length -= 1;
+                _currentLine.Append(GetNewLine());
+                break;
+        }
+    }
+
+    private void FlushCoreAndResetState()
+    {
+        AssertNotClosed();
+
+        if (ShouldWriteToOutput())
+        {
+            _output.Write(_currentLine);
+        }
+
+        _currentLine.Clear();
+        _currentLineState = CurrentLineState.Empty;
+        _currentLineHandlingMode = CurrentLineHandlingMode.Normal;
+    }
+
+    private bool ShouldWriteToOutput() =>
+        _currentLineHandlingMode switch
+        {
+            CurrentLineHandlingMode.Normal => _currentLine.Length > 0,
+            CurrentLineHandlingMode.IgnoreIfEmpty => !CurrentLineIsEmpty(),
+            CurrentLineHandlingMode.IgnoreIfWhiteSpace => !CurrentLineIsWhiteSpace(),
+            CurrentLineHandlingMode.Ignore => false,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+    private bool CurrentLineIsEmpty() =>
+        _currentLine switch
+        {
+            [] => true,
+            ['\r', '\n'] => true,
+            ['\r'] => true,
+            ['\n'] => true,
+            _ => false
+        };
+
+    private bool CurrentLineIsWhiteSpace()
+    {
+        for (var i = _currentLine.Length - 1; i >= 0; i--)
+        {
+            if (!char.IsWhiteSpace(_currentLine[i]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    internal TestAccessor GetTestAccessor() => new(this);
+
+    internal readonly struct TestAccessor(TemplateTextWriter owner)
+    {
+        public TextWriter Output => owner._output;
+
+        public string CurrentLine => owner._currentLine.ToString();
+
+        public CurrentLineState CurrentLineState => owner._currentLineState;
+
+        public CurrentLineHandlingMode CurrentLineHandling => owner._currentLineHandlingMode;
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriterOptions.cs b/src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriterOptions.cs
new file mode 100644
index 0000000..abfbde3
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Output/TemplateTextWriterOptions.cs
@@ -0,0 +1,22 @@
+using System.Globalization;
+
+namespace CodeMe.ScaffoldCS.Templates.Output;
+
+public sealed record TemplateTextWriterOptions(
+    CultureInfo Culture,
+    ReadOnlyMemory<char> Indentation,
+    ReadOnlyMemory<char> SingleIndentation,
+    NewLineFormat NewLineFormat,
+    bool AppendIndentationOnEmptyLines,
+    bool TrimLineEnd,
+    bool NormalizeNewLines)
+{
+    public static readonly TemplateTextWriterOptions Default = new(
+        Culture: CultureInfo.InvariantCulture,
+        Indentation: Array.Empty<char>().AsMemory(),
+        SingleIndentation: "\t".AsMemory(),
+        NewLineFormat: NewLineFormat.Auto,
+        AppendIndentationOnEmptyLines: true,
+        TrimLineEnd: true,
+        NormalizeNewLines: true);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/ClearLineSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Render/ClearLineSymbol.cs
new file mode 100644
index 0000000..4ee204e
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/ClearLineSymbol.cs
@@ -0,0 +1,8 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct ClearLineSymbol : ITemplateSymbol
+{
+    public void Render(Template template) => template.ClearLine();
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderExtensions.cs b/src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderExtensions.cs
new file mode 100644
index 0000000..12dd8e2
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderExtensions.cs
@@ -0,0 +1,26 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public static class CollectionRenderExtensions
+{
+    public static ITemplateSymbol Render<T>(this IEnumerable<T> value, CollectionRenderOptions? options = null) =>
+        new CollectionSymbol<T>(value, null, options ?? CollectionRenderOptions.Default);
+
+    public static ITemplateSymbol Render<T>(
+        this IEnumerable<T> value,
+        Func<T, TemplatePart> format,
+        CollectionRenderOptions? options = null) =>
+        new CollectionSymbol<T>(value, format, options ?? CollectionRenderOptions.Default);
+
+    public static ITemplateSymbol RenderCommaSeparated<T>(this IEnumerable<T> value) =>
+        new CollectionSymbol<T>(value, null, CollectionRenderOptions.CommaSeparated);
+
+    public static ITemplateSymbol RenderEmptyLineSeparated<T>(this IEnumerable<T> value) =>
+        new CollectionSymbol<T>(value, null, CollectionRenderOptions.EmptyLineSeparated);
+
+    public static ITemplateSymbol RenderEmptyLineSeparated<T>(
+        this IEnumerable<T> value,
+        Func<T, TemplatePart> format) =>
+        new CollectionSymbol<T>(value, format, CollectionRenderOptions.EmptyLineSeparated);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderOptions.cs b/src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderOptions.cs
new file mode 100644
index 0000000..c7fbef9
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/CollectionRenderOptions.cs
@@ -0,0 +1,21 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public record CollectionRenderOptions(
+    string? Separator = null,
+    ITemplateSymbol? EmptyValue = null,
+    int Alignment = 0,
+    string? Format = null)
+{
+    public static readonly CollectionRenderOptions CommaSeparated = new(Separator: ", ");
+
+    public static readonly CollectionRenderOptions Multiline = new(Separator: Environment.NewLine);
+
+    public static readonly CollectionRenderOptions EmptyLineSeparated =
+        new(
+            Separator: Environment.NewLine + Environment.NewLine,
+            EmptyValue: Symbols.RemoveWhitespaceLine);
+
+    public static readonly CollectionRenderOptions Default = Multiline;
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/CollectionSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Render/CollectionSymbol.cs
new file mode 100644
index 0000000..9d6a4c9
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/CollectionSymbol.cs
@@ -0,0 +1,45 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct CollectionSymbol<T>(
+    IEnumerable<T> source,
+    Func<T, TemplatePart>? callback,
+    CollectionRenderOptions options) : ITemplateSymbol
+{
+    public void Render(Template template)
+    {
+        var hasFormat = callback == null && (options.Alignment != 0 || options.Format != null);
+
+        var hasItem = false;
+        using var _ = template.BeginOptionsScope(IndentationFormat.CurrentLine);
+        foreach (var item in source)
+        {
+            if (hasItem && !string.IsNullOrEmpty(options.Separator))
+            {
+                template.WriteLiteral(options.Separator);
+            }
+
+            if (callback != null)
+            {
+                template.Write(callback(item));
+            }
+            else if (hasFormat)
+            {
+                template.Write(item, options.Alignment, options.Format);
+            }
+            else
+            {
+                template.Write(item);
+            }
+
+            hasItem = true;
+        }
+
+        if (!hasItem && options.EmptyValue != null)
+        {
+            template.Write(options.EmptyValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/ConditionBranchSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Render/ConditionBranchSymbol.cs
new file mode 100644
index 0000000..0a276b3
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/ConditionBranchSymbol.cs
@@ -0,0 +1,44 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct ConditionBranchSymbol(
+    ConditionBranch branch,
+    bool condition,
+    CurrentLineHandlingMode? lineHandling)
+    : IControlTemplateSymbol
+{
+    public void Render(Template template)
+    {
+        // We need to set line handling before and after branch switching
+        // as we may toggle output on or off
+        if (lineHandling != null)
+        {
+            template.SetLineHandling(lineHandling.Value);
+        }
+
+        switch (branch)
+        {
+            case ConditionBranch.None:
+                template.CompleteIfBranch();
+                break;
+            case ConditionBranch.IfBranch:
+                template.BeginIfBranch(condition);
+                break;
+            case ConditionBranch.ElseIfBranch:
+                template.BeginElseIfBranch(condition);
+                break;
+            case ConditionBranch.ElseBranch:
+                template.BeginElseBranch();
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(branch), branch, null);
+        }
+
+        if (lineHandling != null)
+        {
+            template.SetLineHandling(lineHandling.Value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`1.cs b/src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`1.cs
new file mode 100644
index 0000000..bd403e7
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`1.cs
@@ -0,0 +1,17 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct ConditionSymbol<TTrue>(
+    bool condition,
+    TTrue trueValue)
+    : ITemplateSymbol
+{
+    public void Render(Template template)
+    {
+        if (condition)
+        {
+            template.Write(trueValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`2.cs b/src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`2.cs
new file mode 100644
index 0000000..c620e2a
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/ConditionSymbol`2.cs
@@ -0,0 +1,22 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct ConditionSymbol<TTrue, TFalse>(
+    bool condition,
+    TTrue trueValue,
+    TFalse falseValue)
+    : ITemplateSymbol
+{
+    public void Render(Template template)
+    {
+        if (condition)
+        {
+            template.Write(trueValue);
+        }
+        else
+        {
+            template.Write(falseValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/Conditions.cs b/src/CodeMe.ScaffoldCS.Templates/Render/Conditions.cs
new file mode 100644
index 0000000..88361aa
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/Conditions.cs
@@ -0,0 +1,37 @@
+using System.Collections;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public static class Conditions
+{
+    public static bool HasValue<T>(T? value) =>
+        value switch
+        {
+            null => false,
+            string s => !string.IsNullOrEmpty(s),
+            ICollection collection => collection.Count > 0,
+            IEnumerable enumerable => HasValue(enumerable),
+            _ => !EqualityComparer<T>.Default.Equals(value, default!)
+        };
+
+    public static bool HasValue<T>(ReadOnlySpan<T> value) => value.Length > 0;
+
+    public static bool HasValue<T>(ReadOnlyMemory<T> value) => value.Length > 0;
+
+    public static bool HasValue<T>(IReadOnlyCollection<T> value) => value.Count > 0;
+
+    public static bool HasValue<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> value) => value.Count > 0;
+
+    private static bool HasValue(IEnumerable enumerable)
+    {
+        var enumerator = enumerable.GetEnumerator();
+        try
+        {
+            return enumerator.MoveNext();
+        }
+        finally
+        {
+            (enumerator as IDisposable)?.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/IfFalseTemplatePart.cs b/src/CodeMe.ScaffoldCS.Templates/Render/IfFalseTemplatePart.cs
new file mode 100644
index 0000000..b420a57
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/IfFalseTemplatePart.cs
@@ -0,0 +1,68 @@
+using System.Runtime.CompilerServices;
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+[InterpolatedStringHandler]
+public readonly struct IfFalseTemplatePart<TCondition> : ITemplateScope
+{
+    private readonly Template _template;
+    private readonly Template.OptionsScope _scope;
+
+    public IfFalseTemplatePart(
+        int literalLength,
+        int formattedCount,
+        TCondition condition,
+        out bool isEnabled)
+        : this(literalLength, formattedCount, AmbientTemplate.Current, condition, out isEnabled)
+    {
+    }
+
+    public IfFalseTemplatePart(
+        int literalLength,
+        int formattedCount,
+        Template template,
+        TCondition condition,
+        out bool isEnabled)
+    {
+        isEnabled = !Conditions.HasValue(condition);
+        _template = template;
+        if (isEnabled)
+        {
+            _scope = template.BeginTemplatePartScope();
+        }
+    }
+
+    void ITemplateScope.DisposeIfSame(Template caller) =>
+        _scope.DisposeIfSame(caller);
+
+    public void AppendLiteral(string? value) =>
+        _template.WriteLiteral(value);
+
+    public void AppendFormatted<T>(T? value) =>
+        _template.Write(value);
+
+    public void AppendFormatted<T>(T? value, int alignment) =>
+        _template.Write(value, alignment);
+
+    public void AppendFormatted<T>(T? value, int alignment, string? format) =>
+        _template.Write(value, alignment, format);
+
+    public void AppendFormatted<T>(T? value, string? format) =>
+        _template.Write(value, 0, format);
+
+    public void AppendFormatted(string? value) =>
+        _template.Write(value);
+
+    public void AppendFormatted(string? value, int alignment) =>
+        _template.Write(value, alignment);
+
+    public void AppendFormatted(Action<Template> callback) =>
+        callback(_template);
+
+    public void AppendFormatted(Func<TemplatePart> callback) =>
+        _template.Write(callback());
+
+    public void AppendFormatted<T>(IEnumerable<T> values) =>
+        _template.Write(values);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/IfTrueTemplatePart.cs b/src/CodeMe.ScaffoldCS.Templates/Render/IfTrueTemplatePart.cs
new file mode 100644
index 0000000..13cbc92
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/IfTrueTemplatePart.cs
@@ -0,0 +1,68 @@
+using System.Runtime.CompilerServices;
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+[InterpolatedStringHandler]
+public readonly struct IfTrueTemplatePart<TCondition> : ITemplatePart
+{
+    private readonly Template _template;
+    private readonly Template.OptionsScope _scope;
+
+    public IfTrueTemplatePart(
+        int literalLength,
+        int formattedCount,
+        TCondition condition,
+        out bool isEnabled)
+        : this(literalLength, formattedCount, AmbientTemplate.Current, condition, out isEnabled)
+    {
+    }
+
+    public IfTrueTemplatePart(
+        int literalLength,
+        int formattedCount,
+        Template template,
+        TCondition condition,
+        out bool isEnabled)
+    {
+        isEnabled = Conditions.HasValue(condition);
+        _template = template;
+        if (isEnabled)
+        {
+            _scope = template.BeginTemplatePartScope();
+        }
+    }
+
+    void ITemplateScope.DisposeIfSame(Template caller) =>
+        _scope.DisposeIfSame(caller);
+
+    public void AppendLiteral(string? value) =>
+        _template.WriteLiteral(value);
+
+    public void AppendFormatted<T>(T? value) =>
+        _template.Write(value);
+
+    public void AppendFormatted<T>(T? value, int alignment) =>
+        _template.Write(value, alignment);
+
+    public void AppendFormatted<T>(T? value, int alignment, string? format) =>
+        _template.Write(value, alignment, format);
+
+    public void AppendFormatted<T>(T? value, string? format) =>
+        _template.Write(value, 0, format);
+
+    public void AppendFormatted(string? value) =>
+        _template.Write(value);
+
+    public void AppendFormatted(string? value, int alignment) =>
+        _template.Write(value, alignment);
+
+    public void AppendFormatted(Action<Template> callback) =>
+        callback(_template);
+
+    public void AppendFormatted(Func<TemplatePart> callback) =>
+        _template.Write(callback());
+
+    public void AppendFormatted<T>(IEnumerable<T> values) =>
+        _template.Write(values);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/LineHandlingSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Render/LineHandlingSymbol.cs
new file mode 100644
index 0000000..7a8a821
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/LineHandlingSymbol.cs
@@ -0,0 +1,9 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct LineHandlingSymbol(CurrentLineHandlingMode lineHandling) : ITemplateSymbol
+{
+    public void Render(Template template) => template.SetLineHandling(lineHandling);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/Symbols.cs b/src/CodeMe.ScaffoldCS.Templates/Render/Symbols.cs
new file mode 100644
index 0000000..4a47633
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/Symbols.cs
@@ -0,0 +1,62 @@
+using System.Runtime.CompilerServices;
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public static class Symbols
+{
+    private static readonly CurrentLineHandlingMode _macroLineHandling = CurrentLineHandlingMode.IgnoreIfWhiteSpace;
+
+    public static readonly ValueSymbol<string> NewLine = new(Environment.NewLine);
+
+    public static readonly ClearLineSymbol ClearLine = new();
+
+    public static readonly LineHandlingSymbol RemoveLine = new(CurrentLineHandlingMode.Ignore);
+
+    public static readonly LineHandlingSymbol RemoveEmptyLine = new(CurrentLineHandlingMode.IgnoreIfEmpty);
+
+    public static readonly LineHandlingSymbol RemoveWhitespaceLine = new(CurrentLineHandlingMode.IgnoreIfWhiteSpace);
+
+    public static ConditionBranchSymbol If<T>(T condition) => new(
+        ConditionBranch.IfBranch, Conditions.HasValue(condition), _macroLineHandling);
+
+    public static ConditionBranchSymbol ElseIf<T>(T condition) => new(
+        ConditionBranch.ElseIfBranch, Conditions.HasValue(condition), _macroLineHandling);
+
+    public static readonly ConditionBranchSymbol Else = new(ConditionBranch.ElseBranch, false, _macroLineHandling);
+
+    public static readonly ConditionBranchSymbol EndIf = new(ConditionBranch.None, false, _macroLineHandling);
+
+    public static ConditionSymbol<TTrue> Iif<T, TTrue>(T condition, TTrue trueValue) =>
+        new(Conditions.HasValue(condition), trueValue);
+
+    public static ConditionSymbol<IfTrueTemplatePart<T>> Iif<T>(
+        T condition,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfTrueTemplatePart<T> trueValue) =>
+        new(Conditions.HasValue(condition), trueValue);
+
+    public static ConditionSymbol<TTrue, TFalse> Iif<T, TTrue, TFalse>(
+        T condition,
+        TTrue trueValue,
+        TFalse falseValue) =>
+        new(Conditions.HasValue(condition), trueValue, falseValue);
+
+    public static ConditionSymbol<IfTrueTemplatePart<T>, IfFalseTemplatePart<T>> Iif<T>(
+        T condition,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfTrueTemplatePart<T> trueValue,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfFalseTemplatePart<T> falseValue) =>
+        new(Conditions.HasValue(condition), trueValue, falseValue);
+
+    public static ConditionSymbol<IfTrueTemplatePart<T>, TFalse> Iif<T, TFalse>(
+        T condition,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfTrueTemplatePart<T> trueValue,
+        TFalse falseValue) =>
+        new(Conditions.HasValue(condition), trueValue, falseValue);
+
+    public static ConditionSymbol<TTrue, IfFalseTemplatePart<T>> Iif<T, TTrue>(
+        T condition,
+        TTrue trueValue,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfFalseTemplatePart<T> falseValue) =>
+        new(Conditions.HasValue(condition), trueValue, falseValue);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/SymbolsCS.cs b/src/CodeMe.ScaffoldCS.Templates/Render/SymbolsCS.cs
new file mode 100644
index 0000000..cc3e5ca
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/SymbolsCS.cs
@@ -0,0 +1,55 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+[SuppressMessage("ReSharper", "InconsistentNaming")]
+public static class SymbolsCS
+{
+    public static readonly ValueSymbol<string> NL = Symbols.NewLine;
+
+    public static readonly ClearLineSymbol CL = Symbols.ClearLine;
+
+    public static readonly LineHandlingSymbol RL = Symbols.RemoveLine;
+
+    public static readonly LineHandlingSymbol REL = Symbols.RemoveEmptyLine;
+
+    public static readonly LineHandlingSymbol RWL = Symbols.RemoveWhitespaceLine;
+
+    public static ConditionBranchSymbol IF<T>(T value) => Symbols.If(value);
+
+    public static ConditionBranchSymbol ELSEIF<T>(T value) => Symbols.ElseIf(value);
+
+    public static readonly ConditionBranchSymbol ELSE = Symbols.Else;
+
+    public static readonly ConditionBranchSymbol ENDIF = Symbols.EndIf;
+
+    public static ConditionSymbol<TTrue> IIF<T, TTrue>(T condition, TTrue trueValue) =>
+        Symbols.Iif(condition, trueValue);
+
+    public static ConditionSymbol<IfTrueTemplatePart<T>> IIF<T>(
+        T condition,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfTrueTemplatePart<T> trueValue) =>
+        Symbols.Iif(condition, trueValue);
+
+    public static ConditionSymbol<TTrue, TFalse> IIF<T, TTrue, TFalse>(T condition, TTrue trueValue, TFalse falseValue) =>
+        Symbols.Iif(condition, trueValue, falseValue);
+
+    public static ConditionSymbol<IfTrueTemplatePart<T>, IfFalseTemplatePart<T>> IIF<T>(
+        T condition,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfTrueTemplatePart<T> trueValue,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfFalseTemplatePart<T> falseValue) =>
+        Symbols.Iif(condition, trueValue, falseValue);
+
+    public static ConditionSymbol<IfTrueTemplatePart<T>, TFalse> IIF<T, TFalse>(
+        T condition,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfTrueTemplatePart<T> trueValue,
+        TFalse falseValue) =>
+        Symbols.Iif(condition, trueValue, falseValue);
+
+    public static ConditionSymbol<TTrue, IfFalseTemplatePart<T>> IIF<T, TTrue>(
+        T condition,
+        TTrue trueValue,
+        [InterpolatedStringHandlerArgument(nameof(condition))] IfFalseTemplatePart<T> falseValue) =>
+        Symbols.Iif(condition, trueValue, falseValue);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Render/ValueSymbol.cs b/src/CodeMe.ScaffoldCS.Templates/Render/ValueSymbol.cs
new file mode 100644
index 0000000..010d9d7
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Render/ValueSymbol.cs
@@ -0,0 +1,19 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates.Render;
+
+public readonly struct ValueSymbol<T>(T value, int alignment = 0, string? format = null) : ITemplateSymbol
+{
+    public void Render(Template template)
+    {
+        var hasFormat = alignment != 0 || format != null;
+        if (hasFormat)
+        {
+            template.Write(value, alignment, format);
+        }
+        else
+        {
+            template.Write(value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Template.Context.cs b/src/CodeMe.ScaffoldCS.Templates/Template.Context.cs
new file mode 100644
index 0000000..bcbe892
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Template.Context.cs
@@ -0,0 +1,115 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates;
+
+public partial class Template
+{
+    private readonly Stack<TemplateTextWriterOptions> _optionsStack = new();
+    private readonly Stack<BranchState> _branchesStack = new();
+
+    private BranchState CurrentBranch => _branchesStack.TryPeek(out var x) ? x : BranchState.NoBranch;
+
+    public OptionsScope BeginOptionsScope(IndentationFormat indentationFormat) =>
+        BeginOptionsScope(NewOptions(indentationFormat));
+
+    public OptionsScope BeginOptionsScope(TemplateTextWriterOptions options)
+    {
+        var oldOptions = Options;
+        _optionsStack.Push(oldOptions);
+        Options = options;
+        return new OptionsScope(this, oldOptions);
+    }
+
+    internal OptionsScope BeginTemplatePartScope() =>
+        BeginOptionsScope(IndentationFormat.CurrentLine);
+
+    private TemplateTextWriterOptions NewOptions(IndentationFormat indentationFormat) => Options with
+    {
+        Indentation = _writer.GetCurrentLineIndentation(indentationFormat)
+    };
+
+    private void CompleteScope(TemplateTextWriterOptions options)
+    {
+        if (_optionsStack.Count == 0 || !ReferenceEquals(_optionsStack.Peek(), options))
+        {
+            throw new InvalidOperationException("Cannot complete scope as current options do not match expected ones.");
+        }
+
+        Options = options;
+        _optionsStack.Pop();
+    }
+
+    public void BeginIfBranch(bool condition)
+    {
+        var parent = CurrentBranch;
+
+        var shouldWrite = condition && parent.ConditionMet;
+        _branchesStack.Push(new BranchState(ConditionBranch.IfBranch, shouldWrite, shouldWrite));
+        ShouldWrite = shouldWrite;
+    }
+
+    public void BeginElseIfBranch(bool condition)
+    {
+        var previous = CurrentBranch;
+        if (previous.Branch is not (ConditionBranch.IfBranch or ConditionBranch.ElseIfBranch))
+        {
+            throw new InvalidOperationException($"Cannot begin ElseIf branch after {previous.Branch}");
+        }
+
+        var shouldWrite = condition && !previous.AnyBranchMet;
+        var anyBranchMet = condition || previous.AnyBranchMet;
+        _branchesStack.Pop();
+        _branchesStack.Push(new BranchState(ConditionBranch.ElseIfBranch, shouldWrite, anyBranchMet));
+        ShouldWrite = shouldWrite;
+    }
+
+    public void BeginElseBranch()
+    {
+        var previous = CurrentBranch;
+        if (previous.Branch is not (ConditionBranch.IfBranch or ConditionBranch.ElseIfBranch))
+        {
+            throw new InvalidOperationException($"Cannot begin Else branch after {previous.Branch}");
+        }
+
+        var shouldWrite = !previous.AnyBranchMet;
+        var anyBranchMet = true;
+        _branchesStack.Pop();
+        _branchesStack.Push(new BranchState(ConditionBranch.ElseIfBranch, shouldWrite, anyBranchMet));
+        ShouldWrite = shouldWrite;
+    }
+
+    public void CompleteIfBranch()
+    {
+        var previous = CurrentBranch;
+        if (previous.Branch == ConditionBranch.None)
+        {
+            throw new InvalidOperationException("Cannot complete if/else branch as there is no active branch");
+        }
+
+        _branchesStack.Pop();
+        var current = CurrentBranch;
+        ShouldWrite = current.ConditionMet;
+    }
+
+    public readonly struct OptionsScope(Template owner, TemplateTextWriterOptions oldOptions)
+        : ITemplateScope, IDisposable
+    {
+        public void DisposeIfSame(Template caller)
+        {
+            if (ReferenceEquals(caller, owner))
+            {
+                Dispose();
+            }
+        }
+
+        // ReSharper disable once ConditionalAccessQualifierIsNonNullableAccordingToAPIContract
+        public void Dispose() => owner?.CompleteScope(oldOptions);
+    }
+
+    internal readonly record struct BranchState(ConditionBranch Branch, bool ConditionMet, bool AnyBranchMet)
+    {
+        public static readonly BranchState NoBranch = new(
+            ConditionBranch.None, ConditionMet: true, AnyBranchMet: true);
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Template.TestAccessor.cs b/src/CodeMe.ScaffoldCS.Templates/Template.TestAccessor.cs
new file mode 100644
index 0000000..44f1300
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Template.TestAccessor.cs
@@ -0,0 +1,21 @@
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates;
+
+public partial class Template
+{
+    internal TestAccessor GetTestAccessor() => new(this);
+
+    internal readonly struct TestAccessor(Template owner)
+    {
+        private readonly TemplateTextWriter.TestAccessor _writerAccessor = owner._writer.GetTestAccessor();
+
+        public TextWriter Output => _writerAccessor.Output;
+
+        public IReadOnlyCollection<TemplateTextWriterOptions> OptionsStack => owner._optionsStack;
+
+        public BranchState CurrentBranch => owner.CurrentBranch;
+
+        public IReadOnlyCollection<BranchState> BranchesStack => owner._branchesStack;
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Template.Write.cs b/src/CodeMe.ScaffoldCS.Templates/Template.Write.cs
new file mode 100644
index 0000000..4c67cfa
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Template.Write.cs
@@ -0,0 +1,319 @@
+using System.Collections;
+using System.Runtime.CompilerServices;
+using CodeMe.ScaffoldCS.Templates.Infrastructure;
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+using CodeMe.ScaffoldCS.Templates.Render;
+
+namespace CodeMe.ScaffoldCS.Templates;
+
+public partial class Template
+{
+    public Template SetLineHandling(CurrentLineHandlingMode lineHandling)
+    {
+        if (ShouldWrite)
+        {
+            _writer.SetCurrentLineHandling(lineHandling);
+        }
+
+        return this;
+    }
+
+    public Template ClearLine()
+    {
+        if (ShouldWrite)
+        {
+            _writer.ClearLine();
+        }
+
+        return this;
+    }
+
+    public Template WriteLine()
+    {
+        if (ShouldWrite)
+        {
+            _writer.AppendLine();
+        }
+
+        return this;
+    }
+
+    public Template WriteLiteral(string? value)
+    {
+        if (ShouldWrite)
+        {
+            _writer.Append(value);
+        }
+
+        return this;
+    }
+
+    public Template Write(string? value)
+    {
+        Write(value.AsSpan());
+        return this;
+    }
+
+    public Template Write(string? value, int alignment)
+    {
+        Write(value.AsSpan(), alignment);
+        return this;
+    }
+
+    public Template WriteLine(string? value)
+    {
+        Write(value);
+        WriteLine();
+
+        return this;
+    }
+
+    public Template Write(ReadOnlyMemory<char> value)
+    {
+        Write(value.Span);
+
+        return this;
+    }
+
+    public Template Write(ReadOnlyMemory<char> value, int alignment)
+    {
+        Write(value.Span, alignment);
+
+        return this;
+    }
+
+    public Template WriteLine(ReadOnlyMemory<char> value)
+    {
+        WriteLine(value.Span);
+
+        return this;
+    }
+
+    public Template Write(ReadOnlySpan<char> value)
+    {
+        if (ShouldWrite)
+        {
+            if (value.IsMultiline())
+            {
+                using var _ = BeginOptionsScope(IndentationFormat.CurrentLine);
+                _writer.Append(value);
+            }
+            else
+            {
+                _writer.Append(value);
+            }
+        }
+
+        return this;
+    }
+
+    public Template Write(ReadOnlySpan<char> value, int alignment)
+    {
+        if (ShouldWrite)
+        {
+            _writer.Append(value, alignment);
+        }
+
+        return this;
+    }
+
+    public Template WriteLine(ReadOnlySpan<char> value)
+    {
+        Write(value);
+        WriteLine();
+
+        return this;
+    }
+
+    public Template Write(IEnumerable value)
+    {
+        if (ShouldWrite)
+        {
+            value.Cast<object>().Render(DefaultCollectionRenderOptions).Render(this);
+        }
+
+        return this;
+    }
+
+    public Template Write(IEnumerable value, int alignment, string? format = null)
+    {
+        if (ShouldWrite)
+        {
+            var options = DefaultCollectionRenderOptions with
+            {
+                Alignment = alignment,
+                Format = format
+            };
+            value.Cast<object>().Render(options).Render(this);
+        }
+
+        return this;
+    }
+
+    // TODO: dictionary symbol
+    public Template Write<T>(IEnumerable<T> value)
+    {
+        if (ShouldWrite)
+        {
+            value.Render(DefaultCollectionRenderOptions).Render(this);
+        }
+
+        return this;
+    }
+
+    public Template Write<T>(IEnumerable<T> value, int alignment, string? format = null)
+    {
+        if (ShouldWrite)
+        {
+            var options = DefaultCollectionRenderOptions with
+            {
+                Alignment = alignment,
+                Format = format
+            };
+            value.Render(options).Render(this);
+        }
+
+        return this;
+    }
+
+    public Template Write([InterpolatedStringHandlerArgument("")] TemplatePart value)
+    {
+        ((ITemplateScope)value).DisposeIfSame(this);
+
+        return this;
+    }
+
+    public Template WriteLine([InterpolatedStringHandlerArgument("")] TemplatePart value)
+    {
+        Write(value);
+        WriteLine();
+
+        return this;
+    }
+
+    internal Template CompleteScope<TScoped>(TScoped value)
+        where TScoped : ITemplateScope
+    {
+        value.DisposeIfSame(this);
+
+        return this;
+    }
+
+    public Template Write(ITemplateSymbol value)
+    {
+        if (ShouldWrite || value is IControlTemplateSymbol)
+        {
+            value.Render(this);
+        }
+
+        return this;
+    }
+
+    public Template Write<T>(T? value)
+    {
+        if (value is null)
+        {
+            Write((string?)null);
+            return this;
+        }
+
+        if (value is string @string)
+        {
+            Write(@string);
+            return this;
+        }
+
+        if (value is ReadOnlyMemory<char> memory)
+        {
+            Write(memory);
+            return this;
+        }
+
+        if (value is ITemplateScope)
+        {
+            ((ITemplateScope)value).DisposeIfSame(this);
+            return this;
+        }
+
+        if (value is ITemplateSymbol)
+        {
+            if (ShouldWrite || value is IControlTemplateSymbol)
+            {
+                ((ITemplateSymbol)value).Render(this);
+            }
+
+            return this;
+        }
+
+        if (value is IEnumerable enumerable)
+        {
+            Write(enumerable);
+            return this;
+        }
+
+        if (ShouldWrite)
+        {
+            _writer.Append(value);
+        }
+
+        return this;
+    }
+
+    public Template Write<T>(T? value, int alignment, string? format = null)
+    {
+        if (value is null)
+        {
+            Write((string?)null);
+            return this;
+        }
+
+        if (value is string @string)
+        {
+            Write(@string, alignment);
+            return this;
+        }
+
+        if (value is ReadOnlyMemory<char> memory)
+        {
+            Write(memory, alignment);
+            return this;
+        }
+
+        if (value is TemplatePart templatePart)
+        {
+            Write(templatePart);
+            return this;
+        }
+
+        if (value is ITemplateSymbol)
+        {
+            if (ShouldWrite || value is IControlTemplateSymbol)
+            {
+                ((ITemplateSymbol)value).Render(this);
+            }
+
+            return this;
+        }
+
+        if (value is IEnumerable enumerable)
+        {
+            Write(enumerable, alignment, format);
+            return this;
+        }
+
+        if (ShouldWrite)
+        {
+            _writer.Append(value, alignment, format);
+        }
+
+        return this;
+    }
+
+    public Template WriteLine<T>(T? value)
+    {
+        Write(value);
+        WriteLine();
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/Template.cs b/src/CodeMe.ScaffoldCS.Templates/Template.cs
new file mode 100644
index 0000000..5f6bcff
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/Template.cs
@@ -0,0 +1,56 @@
+using CodeMe.ScaffoldCS.Templates.Internals;
+using CodeMe.ScaffoldCS.Templates.Output;
+using CodeMe.ScaffoldCS.Templates.Render;
+
+namespace CodeMe.ScaffoldCS.Templates;
+
+public sealed partial class Template : IDisposable
+{
+    private readonly TemplateTextWriter _writer;
+
+    public Template(TextWriter output, TemplateTextWriterOptions? options = null, bool leaveOpen = false)
+    {
+        _writer = new TemplateTextWriter(output, options, leaveOpen);
+        ShouldWrite = true;
+        ValidateOnClose = true;
+        DefaultCollectionRenderOptions = CollectionRenderOptions.Default;
+    }
+
+    public bool ValidateOnClose { get; set; }
+
+    public TemplateTextWriterOptions Options
+    {
+        get => _writer.Options;
+        set => _writer.Options = value;
+    }
+
+    public CollectionRenderOptions DefaultCollectionRenderOptions { get; set; }
+
+    public bool ShouldWrite { get; private set; }
+
+    public void Dispose()
+    {
+        if (ValidateOnClose)
+        {
+            if (_branchesStack.Count > 0)
+            {
+                throw new InvalidOperationException(
+                    "There is unclosed 'if' or 'else' branch. Please fix the template content"
+                    + $" or disable the {nameof(ValidateOnClose)} option.");
+            }
+
+            if (_optionsStack.Count > 0)
+            {
+                throw new InvalidOperationException(
+                    "There is unclosed options scope."
+                    + $" Please dispose all {nameof(BeginOptionsScope)} scopes.");
+            }
+        }
+
+        _writer.Dispose();
+    }
+
+    public void Close() => Dispose();
+
+    public IDisposable BeginAmbientScope() => AmbientTemplate.BeginTemplateScope(this);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/TemplatePart.cs b/src/CodeMe.ScaffoldCS.Templates/TemplatePart.cs
new file mode 100644
index 0000000..4dc31b5
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/TemplatePart.cs
@@ -0,0 +1,56 @@
+using System.Runtime.CompilerServices;
+using CodeMe.ScaffoldCS.Templates.Internals;
+
+namespace CodeMe.ScaffoldCS.Templates;
+
+[InterpolatedStringHandler]
+public readonly struct TemplatePart : ITemplatePart
+{
+    private readonly Template _template;
+
+    private readonly Template.OptionsScope _scope;
+
+    public TemplatePart(int literalLength, int formattedCount)
+        : this(literalLength, formattedCount, AmbientTemplate.Current)
+    {
+    }
+
+    public TemplatePart(int literalLength, int formattedCount, Template template)
+    {
+        _template = template;
+        _scope = template.BeginTemplatePartScope();
+    }
+
+    void ITemplateScope.DisposeIfSame(Template caller) =>
+        _scope.DisposeIfSame(caller);
+
+    public void AppendLiteral(string? value) =>
+        _template.WriteLiteral(value);
+
+    public void AppendFormatted<T>(T? value) =>
+        _template.Write(value);
+
+    public void AppendFormatted<T>(T? value, int alignment) =>
+        _template.Write(value, alignment);
+
+    public void AppendFormatted<T>(T? value, int alignment, string? format) =>
+        _template.Write(value, alignment, format);
+
+    public void AppendFormatted<T>(T? value, string? format) =>
+        _template.Write(value, 0, format);
+
+    public void AppendFormatted(string? value) =>
+        _template.Write(value);
+
+    public void AppendFormatted(string? value, int alignment) =>
+        _template.Write(value, alignment);
+
+    public void AppendFormatted(Action<Template> callback) =>
+        callback(_template);
+
+    public void AppendFormatted(Func<TemplatePart> callback) =>
+        _template.Write(callback());
+
+    public void AppendFormatted<T>(IEnumerable<T> values) =>
+        _template.Write(values);
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS.Templates/packages.lock.json b/src/CodeMe.ScaffoldCS.Templates/packages.lock.json
new file mode 100644
index 0000000..6ea9702
--- /dev/null
+++ b/src/CodeMe.ScaffoldCS.Templates/packages.lock.json
@@ -0,0 +1,13 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "CodeMe.Basics": {
+        "type": "Direct",
+        "requested": "[0.0.3, )",
+        "resolved": "0.0.3",
+        "contentHash": "nNgoT45Ta8mefmm+6nh6jOVdqa2+FIirsCAYQZNsJEBGPSaenBnunh3ezhCZD1kaV+fvW+a5ybAWWlYiyem47Q=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS/CodeMe.ScaffoldCS.csproj b/src/CodeMe.ScaffoldCS/CodeMe.ScaffoldCS.csproj
index 7c9158a..651a366 100644
--- a/src/CodeMe.ScaffoldCS/CodeMe.ScaffoldCS.csproj
+++ b/src/CodeMe.ScaffoldCS/CodeMe.ScaffoldCS.csproj
@@ -6,4 +6,8 @@
 		<PackageTags>Scaffolld;Template;Codegen;Code Generation</PackageTags>
 	</PropertyGroup>
 
+	<ItemGroup>
+	  <ProjectReference Include="..\CodeMe.ScaffoldCS.Templates\CodeMe.ScaffoldCS.Templates.csproj" />
+	</ItemGroup>
+
 </Project>
\ No newline at end of file
diff --git a/src/CodeMe.ScaffoldCS/README.md b/src/CodeMe.ScaffoldCS/README.md
index 5075096..1c2b6d1 100644
--- a/src/CodeMe.ScaffoldCS/README.md
+++ b/src/CodeMe.ScaffoldCS/README.md
@@ -1,2 +1,2 @@
 # CodeMe.ScaffoldCS
-Scaffolding framework inspired by CodegenCS
\ No newline at end of file
+Scaffolding framework inspired by CodegenCS
diff --git a/src/CodeMe.ScaffoldCS/packages.lock.json b/src/CodeMe.ScaffoldCS/packages.lock.json
index 6afd678..8ee316a 100644
--- a/src/CodeMe.ScaffoldCS/packages.lock.json
+++ b/src/CodeMe.ScaffoldCS/packages.lock.json
@@ -1,6 +1,19 @@
 {
   "version": 2,
   "dependencies": {
-    "net10.0": {}
+    "net10.0": {
+      "codeme.scaffoldcs.templates": {
+        "type": "Project",
+        "dependencies": {
+          "CodeMe.Basics": "[0.0.3, )"
+        }
+      },
+      "CodeMe.Basics": {
+        "type": "CentralTransitive",
+        "requested": "[0.0.3, )",
+        "resolved": "0.0.3",
+        "contentHash": "nNgoT45Ta8mefmm+6nh6jOVdqa2+FIirsCAYQZNsJEBGPSaenBnunh3ezhCZD1kaV+fvW+a5ybAWWlYiyem47Q=="
+      }
+    }
   }
 }
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/CodeMe.ScaffoldCS.Templates.UnitTests.csproj b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/CodeMe.ScaffoldCS.Templates.UnitTests.csproj
new file mode 100644
index 0000000..00b9359
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/CodeMe.ScaffoldCS.Templates.UnitTests.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+  </PropertyGroup>
+
+</Project>
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Class.cs b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Class.cs
new file mode 100644
index 0000000..ac35885
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Class.cs
@@ -0,0 +1,3 @@
+namespace CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure.Models;
+
+public record Class(string Name, string Comment, IReadOnlyCollection<Property> Properties);
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Property.cs b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Property.cs
new file mode 100644
index 0000000..f393f03
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/Models/Property.cs
@@ -0,0 +1,3 @@
+namespace CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure.Models;
+
+public record Property(string Name, string Type, string? Comment);
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTestExtensions.cs b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTestExtensions.cs
new file mode 100644
index 0000000..31c62ba
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTestExtensions.cs
@@ -0,0 +1,30 @@
+using AwesomeAssertions.Execution;
+
+namespace CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure;
+
+internal static class TemplateTestExtensions
+{
+    public static string GetOutput(this Template template)
+    {
+        var output = (StringWriter)template.GetTestAccessor().Output;
+
+        return output.ToString();
+    }
+
+    public static Template ShouldBe(
+        this Template template,
+        string rendered)
+    {
+        var testAccessor = template.GetTestAccessor();
+        var output = (StringWriter)testAccessor.Output;
+        template.Close();
+
+        using var _ = new AssertionScope();
+        var current = output.ToString();
+        current.Should().Be(rendered);
+        testAccessor.BranchesStack.Count.Should().Be(0);
+        testAccessor.OptionsStack.Count.Should().Be(0);
+
+        return template;
+    }
+}
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTextWriterTestExtensions.cs b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTextWriterTestExtensions.cs
new file mode 100644
index 0000000..b7bf1d7
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Infrastructure/TemplateTextWriterTestExtensions.cs
@@ -0,0 +1,75 @@
+using System.Globalization;
+using AwesomeAssertions.Execution;
+using CodeMe.ScaffoldCS.Templates.Output;
+
+namespace CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure;
+
+internal static class TemplateTextWriterTestExtensions
+{
+    public static TemplateTextWriter WithCulture(this TemplateTextWriter templateWriter, string cultureName)
+    {
+        templateWriter.Options = templateWriter.Options with { Culture = new CultureInfo(cultureName) };
+        return templateWriter;
+    }
+
+    public static TemplateTextWriter WithIndentation(this TemplateTextWriter templateWriter, string indentation)
+    {
+        templateWriter.Options = templateWriter.Options with { Indentation = indentation.AsMemory() };
+        return templateWriter;
+    }
+
+    public static TemplateTextWriter WithNewLineFormat(this TemplateTextWriter templateWriter, NewLineFormat format)
+    {
+        templateWriter.Options = templateWriter.Options with { NewLineFormat = format };
+        return templateWriter;
+    }
+
+    public static TemplateTextWriter WithIndentationOnEmptyLines(this TemplateTextWriter templateWriter, bool enabled)
+    {
+        templateWriter.Options = templateWriter.Options with { AppendIndentationOnEmptyLines = enabled };
+        return templateWriter;
+    }
+
+    public static TemplateTextWriter WithTrimLineEnd(this TemplateTextWriter templateWriter, bool enabled)
+    {
+        templateWriter.Options = templateWriter.Options with { TrimLineEnd = enabled };
+        return templateWriter;
+    }
+
+    public static TemplateTextWriter WithNormalizeNewLines(this TemplateTextWriter templateWriter, bool enabled)
+    {
+        templateWriter.Options = templateWriter.Options with { NormalizeNewLines = enabled };
+        return templateWriter;
+    }
+
+    public static string GetOutput(this TemplateTextWriter templateWriter)
+    {
+        var output = (StringWriter)templateWriter.GetTestAccessor().Output;
+
+        return output.ToString();
+    }
+
+    public static TemplateTextWriter ShouldBe(
+        this TemplateTextWriter templateWriter,
+        string rendered,
+        string? beforeClose = null)
+    {
+        var testAccessor = templateWriter.GetTestAccessor();
+        var output = (StringWriter)testAccessor.Output;
+
+        var capturedBeforeClose = output.ToString();
+        templateWriter.Close();
+
+        using var _ = new AssertionScope();
+        output.ToString().Should().Be(rendered);
+        if (beforeClose != null)
+        {
+            capturedBeforeClose.Should().Be(capturedBeforeClose);
+        }
+
+        testAccessor.CurrentLine.Should().Be("");
+        testAccessor.CurrentLineState.Should().Be(CurrentLineState.Closed);
+
+        return templateWriter;
+    }
+}
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Output/TemplateTextWriterTests.cs b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Output/TemplateTextWriterTests.cs
new file mode 100644
index 0000000..a5af34f
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/Output/TemplateTextWriterTests.cs
@@ -0,0 +1,997 @@
+using CodeMe.ScaffoldCS.Templates.Output;
+using CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure;
+
+namespace CodeMe.ScaffoldCS.Templates.UnitTests.Output;
+
+public class TemplateTextWriterTests
+{
+    [Fact]
+    public void TestScenario_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer
+            .Append(
+                """
+                
+                Hello
+
+                World
+                """)
+            .Append("\n ")
+            .Append("\r\n");
+
+        // Assert
+        writer.ShouldBe(
+            """
+              //
+              // Hello
+              //
+              // World
+              //
+            
+            """);
+    }
+
+    [Fact]
+    public void Empty_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Assert
+        writer.ShouldBe("", beforeClose: "");
+    }
+
+    [Fact]
+    public void Empty_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Assert
+        writer.ShouldBe("", beforeClose: "");
+    }
+
+    [Fact]
+    public void NormalText_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append("Hello");
+
+        // Assert
+        writer.ShouldBe("Hello", beforeClose: "");
+    }
+
+    [Fact]
+    public void NormalText_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append("Hello");
+
+        // Assert
+        writer.ShouldBe("  // Hello", beforeClose: "");
+    }
+
+    [Fact]
+    public void NormalText_LeftPadding_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .Append('\'')
+            .Append("Hello", 8)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("'   Hello'");
+    }
+
+    [Fact]
+    public void NormalText_LeftPadding_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer
+            .Append('\'')
+            .Append("Hello", 8)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("  // '   Hello'");
+    }
+
+    [Fact]
+    public void NormalText_RightPadding_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .Append('\'')
+            .Append("Hello", -8)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("'Hello   '");
+    }
+
+    [Fact]
+    public void NormalText_Multiline_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer.Append("Hello,\r\nworld!");
+
+        // Assert
+        writer.ShouldBe("Hello,\nworld!", beforeClose: "Hello,\n");
+    }
+
+    [Fact]
+    public void NormalText_Multiline_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf)
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append("Hello,\r\nworld!");
+
+        // Assert
+        writer.ShouldBe("  // Hello,\n  // world!");
+    }
+
+    [Fact]
+    public void NormalText_Multiline_LeftPadding_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append('\'')
+            .Append("A\r\nB", 8)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("'    A\nB'");
+    }
+
+    [Fact]
+    public void NormalText_Multiline_RightPadding_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append('\'')
+            .Append("A\r\nB", -8)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("'A\nB    '");
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append(
+            """
+              Hello,
+
+              world!
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+              Hello,
+
+              world!
+            """,
+            beforeClose:
+            """
+              Hello,
+            
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append(
+            """
+            Hello,
+
+            world!
+
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+              // Hello,
+              //
+              // world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_WithNonEmptyIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ")
+            .WithIndentationOnEmptyLines(false);
+
+        // Act
+        writer.Append(
+            """
+            Hello,
+
+            world!
+
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+              // Hello,
+            
+              // world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_AsGeneric_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append<string>(
+            """
+            Hello,
+
+            world!
+
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+              // Hello,
+              //
+              // world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_AsGenericMemory_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append<ReadOnlyMemory<char>>(
+            """
+            Hello,
+
+            world!
+
+            """.AsMemory());
+
+        // Assert
+        writer.ShouldBe(
+            """
+              // Hello,
+              //
+              // world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_AsSpan_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append(
+            """
+            Hello,
+
+            world!
+
+            """.AsSpan());
+
+        // Assert
+        writer.ShouldBe(
+            """
+              // Hello,
+              //
+              // world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineLiteral_AsMemory_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ");
+
+        // Act
+        writer.Append(
+            """
+            Hello,
+
+            world!
+
+            """.AsMemory());
+
+        // Assert
+        writer.ShouldBe(
+            """
+              // Hello,
+              //
+              // world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineWrites_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .AppendLine()
+            .Append("Hello, ")
+            .AppendLine()
+            .Append("  world!")
+            .AppendLine();
+
+        // Assert
+        writer.ShouldBe(
+            """
+
+            Hello,
+              world!
+
+            """,
+            beforeClose:
+            """
+
+            Hello,
+              world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineWrites_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("// ");
+
+        // Act
+        writer
+            .AppendLine()
+            .Append("Hello, ")
+            .AppendLine()
+            .Append("  world!")
+            .AppendLine();
+
+        // Assert
+        writer.ShouldBe(
+            """
+            //
+            // Hello,
+            //   world!
+            
+            """,
+            beforeClose:
+            """
+            //
+            // Hello,
+            //   world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_MultilineWrites_WithNonEmptyIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("// ")
+            .WithIndentationOnEmptyLines(false);
+
+        // Act
+        writer
+            .AppendLine()
+            .Append("Hello, ")
+            .AppendLine()
+            .Append("  world!")
+            .AppendLine();
+
+        // Assert
+        writer.ShouldBe(
+            """
+            
+            // Hello,
+            //   world!
+            
+            """,
+            beforeClose:
+            """
+            
+            // Hello,
+            //   world!
+            
+            """);
+    }
+
+    [Fact]
+    public void NormalText_WhitespaceAndMultiline_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer.Append("Hello, \r\n world!");
+
+        // Assert
+        writer.ShouldBe("Hello,\n world!");
+    }
+
+    [Fact]
+    public void Value_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append(1.2);
+
+        // Assert
+        writer.ShouldBe("1.2", beforeClose: "");
+    }
+
+    [Fact]
+    public void Value_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("// ");
+
+        // Act
+        writer.Append(1.2);
+
+        // Assert
+        writer.ShouldBe("// 1.2");
+    }
+
+    [Fact]
+    public void Value_CustomCulture_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithCulture("ru-RU");
+
+        // Act
+        writer.Append(1.2);
+
+        // Assert
+        writer.ShouldBe("1,2");
+    }
+
+    [Fact]
+    public void Value_CustomFormat_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append(1.2, 0, "F4");
+
+        // Assert
+        writer.ShouldBe("1.2000");
+    }
+
+    [Fact]
+    public void Value_LeftPadding_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .Append('\'')
+            .Append(1.2, 4, null)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("' 1.2'");
+    }
+
+    [Fact]
+    public void Value_RightPadding_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .Append('\'')
+            .Append(1.2, -4, null)
+            .Append('\'');
+
+        // Assert
+        writer.ShouldBe("'1.2 '");
+    }
+
+    [Fact]
+    public void Whitespace_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append("  \t \v ");
+
+        // Assert
+        writer.ShouldBe("");
+    }
+
+    [Fact]
+    public void Whitespace_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("// ");
+
+        // Act
+        writer.Append("  \t \v ");
+
+        // Assert
+        writer.ShouldBe("//");
+    }
+
+    [Fact]
+    public void Whitespace_NoTrim_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithTrimLineEnd(false);
+
+        // Act
+        writer.Append("  \t \v ");
+
+        // Assert
+        writer.ShouldBe("  \t \v ");
+    }
+
+    [Fact]
+    public void NewLine_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append("\n\r\n\r\r");
+
+        // Assert
+        var expected = string.Join("", Enumerable.Repeat(Environment.NewLine, 4));
+        var expectedBeforeClose = string.Join("", Enumerable.Repeat(Environment.NewLine, 3));
+        writer.ShouldBe(expected, beforeClose: expectedBeforeClose);
+    }
+
+    [Fact]
+    public void NewLine_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("// ");
+
+        // Act
+        writer.Append("\n\r\n\r\r");
+
+        // Assert
+        writer.ShouldBe(
+            """
+            //
+            //
+            //
+            //
+            
+            """);
+    }
+
+    [Fact]
+    public void NewLine_WithNonEmptyIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("// ")
+            .WithIndentationOnEmptyLines(false);
+
+        // Act
+        writer.Append("\n \r\n \r \r");
+
+        // Assert
+        writer.ShouldBe(
+            """
+            
+            //
+            //
+            //
+            
+            """);
+    }
+
+    [Fact]
+    public void NewLine_WithNonEmptyIndentation_Whitespace_NoTrimLine_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ")
+            .WithIndentationOnEmptyLines(false)
+            .WithTrimLineEnd(false)
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer.Append("\n \n \n \n");
+
+        // Assert
+        writer.ShouldBe("\n  //  \n  //  \n  //  \n");
+    }
+
+    [Fact]
+    public void NewLine_Whitespace_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer.Append("\r \n ");
+
+        // Assert
+        writer.ShouldBe("\n\n", beforeClose: "\n\n");
+    }
+
+    [Fact]
+    public void NewLine_WhitespaceNoTrim_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf)
+            .WithTrimLineEnd(false);
+
+        // Act
+        writer.Append("\r \n ");
+
+        // Assert
+        writer.ShouldBe("\n \n ", beforeClose: "\n \n");
+    }
+
+    [Fact]
+    public void NewLine_NoNormalization_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNormalizeNewLines(false);
+
+        // Act
+        writer.Append("\n\r\n\r\r");
+
+        // Assert
+        writer.ShouldBe("\n\r\n\r\r", beforeClose: "\n\r\n\r");
+    }
+
+    [Fact]
+    public void NewLine_NoNormalization_WithIndentation_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithIndentation("  // ")
+            .WithNormalizeNewLines(false);
+
+        // Act
+        writer.Append("\n\r\n\r\r");
+
+        // Assert
+        writer.ShouldBe("  //\n  //\r\n  //\r  //\r");
+    }
+
+    [Fact]
+    public void NewLine_Custom_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer.Append("\n\r\n\r\r");
+
+        // Assert
+        writer.ShouldBe("\n\n\n\n");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_Ignore_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .SetCurrentLineHandling(CurrentLineHandlingMode.Ignore)
+            .Append("Hello");
+
+        // Assert
+        writer.ShouldBe("", beforeClose: "");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_Ignore_AfterAppend_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer
+            .Append("Hello")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.Ignore);
+
+        // Assert
+        writer.ShouldBe("", beforeClose: "");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_Ignore_Multiline_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .SetCurrentLineHandling(CurrentLineHandlingMode.Ignore)
+            .Append("Hello\nworld!");
+
+        // Assert
+        writer.ShouldBe("world!", beforeClose: "");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_Ignore_AfterAppend_Multiline_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append("Hello\nworld!")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.Ignore);
+
+        // Assert
+        writer.ShouldBe("Hello\n", beforeClose: "Hello\n");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_IgnoreIfEmpty_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append("A\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfEmpty)
+            .Append(" \t \v \r\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfEmpty)
+            .Append("\n")
+            .Append("B\n");
+
+        // Assert
+        writer.ShouldBe("A\nB\n", beforeClose: "A\nB\n");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_IgnoreIfEmpty_NonEmpty_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append("A\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfEmpty)
+            .Append("B \n")
+            .Append("C\n");
+
+        // Assert
+        writer.ShouldBe("A\nB\nC\n");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_IgnoreIfEmpty_NoTrim_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf)
+            .WithTrimLineEnd(false);
+
+        // Act
+        writer
+            .Append("A\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfEmpty)
+            .Append(" \t \v \r\n")
+            .Append("B\n");
+
+        // Assert
+        writer.ShouldBe("A\n \t \v \nB\n");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_IgnoreIfWhitespace_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf)
+            .WithTrimLineEnd(false);
+
+        // Act
+        writer
+            .Append("A\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfWhiteSpace)
+            .Append(" \t \v \r\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfWhiteSpace)
+            .Append("\n")
+            .Append("B\n");
+
+        // Assert
+        writer.ShouldBe("A\nB\n", beforeClose: "A\nB\n");
+    }
+
+    [Fact]
+    public void SetCurrentLineHandling_IgnoreIfWhitespace_NonEmpty_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append("A\n")
+            .SetCurrentLineHandling(CurrentLineHandlingMode.IgnoreIfWhiteSpace)
+            .Append("B \n")
+            .Append("C\n");
+
+        // Assert
+        writer.ShouldBe("A\nB\nC\n");
+    }
+
+    [Fact]
+    public void ClearLine_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append("A\n")
+            .Append("B")
+            .ClearLine()
+            .Append("\n")
+            .Append("C\n");
+
+        // Assert
+        writer.ShouldBe("A\n\nC\n");
+    }
+
+    [Fact]
+    public void ClearLine_AfterLineEnd_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter()
+            .WithNewLineFormat(NewLineFormat.Lf);
+
+        // Act
+        writer
+            .Append("A\n")
+            .Append("B\n")
+            .ClearLine()
+            .Append("C\n");
+
+        // Assert
+        writer.ShouldBe("A\nB\nC\n");
+    }
+
+    [Fact]
+    public void MultipleClose_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTextWriter();
+
+        // Act
+        writer.Append("Hello");
+        writer.Close();
+        writer.Close();
+
+        // Assert
+        writer.ShouldBe("Hello");
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Append_AfterClose_ShouldThrow(bool leaveOpen)
+    {
+        // Arrange
+        var writer = new TemplateTextWriter(new StringWriter(), leaveOpen: leaveOpen);
+
+        // Act
+        writer.Append("Hello");
+        writer.Close();
+        Assert.Throws<ObjectDisposedException>(() => writer.Append(", world!"));
+
+        // Assert
+        writer.ShouldBe("Hello");
+    }
+
+    private static TemplateTextWriter CreateTextWriter() => new(new StringWriter());
+}
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/TemplateTests.cs b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/TemplateTests.cs
new file mode 100644
index 0000000..7cbc3ab
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/TemplateTests.cs
@@ -0,0 +1,350 @@
+using CodeMe.ScaffoldCS.Templates.Render;
+using CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure;
+using CodeMe.ScaffoldCS.Templates.UnitTests.Infrastructure.Models;
+
+namespace CodeMe.ScaffoldCS.Templates.UnitTests;
+
+using static SymbolsCS;
+
+public class TemplateTests
+{
+    private static readonly Class _testDto = new(
+        "TestDto",
+        "Test details",
+        [
+            new Property("Id", "long", "Identifier"),
+            new Property("Name", "string", "Dto name\ndetails"),
+            new Property("CreatedAt", "DateTimeOffset", null)
+        ]);
+
+    [Fact]
+    public void TestScenario_ShouldBeExpected()
+    {
+        // Arrange
+        var dto = _testDto;
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $$"""
+            using System;
+            
+            namespace TestModels;
+            
+            {{IF(dto.Comment)}}/// <summary>
+            /// {{dto.Comment}}.
+            /// </summary>{{ENDIF}}
+            public class {{dto.Name}}
+            {
+                {{dto.Properties.RenderEmptyLineSeparated(RenderProperty)}}
+            }
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            using System;
+            
+            namespace TestModels;
+
+            /// <summary>
+            /// Test details.
+            /// </summary>
+            public class TestDto
+            {
+                /// <summary>
+                /// Identifier.
+                /// </summary>
+                public long Id { get; set; }
+
+                /// <summary>
+                /// Dto name
+                /// details.
+                /// </summary>
+                public string Name { get; set; }
+
+                public DateTimeOffset CreatedAt { get; set; }
+            }
+            """);
+    }
+
+    [Fact]
+    public void TestScenario_EmptyProperties_ShouldBeExpected()
+    {
+        // Arrange
+        var dto = _testDto with
+        {
+            Properties = []
+        };
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $$"""
+            using System;
+            
+            namespace TestModels;
+            
+            {{IF(dto.Comment)}}/// <summary>
+            /// {{dto.Comment}}.
+            /// </summary>{{ENDIF}}
+            public class {{dto.Name}}
+            {
+                {{dto.Properties.RenderEmptyLineSeparated(RenderProperty)}}
+            }
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            using System;
+            
+            namespace TestModels;
+
+            /// <summary>
+            /// Test details.
+            /// </summary>
+            public class TestDto
+            {
+            }
+            """);
+    }
+
+    [Fact]
+    public void TestScenario_IfComment_ShouldBeExpected()
+    {
+        // Arrange
+        var dto = _testDto with
+        {
+            Comment = "",
+            Properties = []
+        };
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $$"""
+            using System;
+            
+            namespace TestModels;
+            
+            {{IF(dto.Comment)}}/// <summary>
+            /// {{dto.Comment}}.
+            /// </summary>{{ENDIF}}
+            public class {{dto.Name}}
+            {
+                {{dto.Properties.RenderEmptyLineSeparated(RenderProperty)}}
+            }
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            using System;
+            
+            namespace TestModels;
+
+            public class TestDto
+            {
+            }
+            """);
+    }
+
+    [Fact]
+    public void TestScenario_IfTrue_ShouldBeExpected()
+    {
+        // Arrange
+        var dto = _testDto with
+        {
+            Properties = []
+        };
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $$"""
+            using System;
+            
+            namespace TestModels;
+            
+            {{IF(dto.Comment)}}/// <summary>
+            /// {{dto.Comment}}.
+            /// </summary>{{ENDIF}}
+            public class {{dto.Name}}
+            {
+                {{IF(dto.Properties)}}
+                #region {{dto.Name}} properties
+                {{dto.Properties.RenderEmptyLineSeparated(RenderProperty)}}
+                #endregion
+                {{ENDIF}}
+            }
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            using System;
+
+            namespace TestModels;
+
+            /// <summary>
+            /// Test details.
+            /// </summary>
+            public class TestDto
+            {
+            }
+            """);
+    }
+
+    [Fact]
+    public void TestScenario_IfFalse_ShouldBeExpected()
+    {
+        // Arrange
+        var dto = _testDto;
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $$"""
+            using System;
+            
+            namespace TestModels;
+            
+            {{IF(dto.Comment)}}/// <summary>
+            /// {{dto.Comment}}.
+            /// </summary>{{ENDIF}}
+            public class {{dto.Name}}
+            {
+                {{IF(dto.Properties)}}
+                #region {{dto.Name}} properties
+                {{dto.Properties.RenderEmptyLineSeparated(RenderProperty)}}
+                #endregion
+                {{ENDIF}}
+            }
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            using System;
+
+            namespace TestModels;
+
+            /// <summary>
+            /// Test details.
+            /// </summary>
+            public class TestDto
+            {
+                #region TestDto properties
+                /// <summary>
+                /// Identifier.
+                /// </summary>
+                public long Id { get; set; }
+
+                /// <summary>
+                /// Dto name
+                /// details.
+                /// </summary>
+                public string Name { get; set; }
+
+                public DateTimeOffset CreatedAt { get; set; }
+                #endregion
+            }
+            """);
+    }
+
+    [Fact]
+    public void Iif_True_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $"""
+            True={IIF(1, 1)}.
+            False={IIF(0, 1)}.
+            True={IIF(1, 1, 2)}.
+            False={IIF(0, 1, 2)}.
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            True=1.
+            False=.
+            True=1.
+            False=2.
+            """);
+    }
+
+    [Fact]
+    public void Iif_True_Template_ShouldBeExpected()
+    {
+        // Arrange
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+
+        // Act
+        writer.Write(
+            $"""
+            True={IIF(1, $"Hi, '{_testDto.Name}'")}!
+            False={IIF(0, $"Hi, '{_testDto.Name}'")}!
+            True={IIF(1, $"Hi, '{_testDto.Name}'", RL)}!
+            False={IIF(0, $"Hi, '{_testDto.Name}'", RL)}!
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            True=Hi, 'TestDto'!
+            False=!
+            True=Hi, 'TestDto'!
+            
+            """);
+    }
+
+    [Fact]
+    public void MultipleRemoveLine_ShouldBeExpected()
+    {
+        // Arrange
+        var dto = _testDto;
+        var writer = CreateTemplate();
+        using var _ = writer.BeginAmbientScope();
+        // Act
+        writer.Write(
+            $"""
+            {RL}
+            {RL}
+            {RL}
+            """);
+
+        // Assert
+        writer.ShouldBe(
+            """
+            
+            """);
+    }
+
+    private static TemplatePart RenderProperty(Property property) =>
+        $$"""
+        {{IF(property.Comment)}}
+        /// <summary>
+        /// {{property.Comment}}.
+        /// </summary>
+        {{ENDIF}}
+        public {{property.Type}} {{property.Name}} { get; set; }
+        """;
+
+    private static Template CreateTemplate()
+    {
+        var template = new Template(new StringWriter());
+        return template;
+    }
+}
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.Templates.UnitTests/packages.lock.json b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/packages.lock.json
new file mode 100644
index 0000000..18c5ee0
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.Templates.UnitTests/packages.lock.json
@@ -0,0 +1,154 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "AwesomeAssertions": {
+        "type": "Direct",
+        "requested": "[9.5.0, )",
+        "resolved": "9.5.0",
+        "contentHash": "F92MsjoF8B7IdcWETru4QGZx6VAl38qQPKNGS3kwPwlLB5lb0O4bhFqG8a8sz2estQJWkKmZkVy1r19HTaFcpg=="
+      },
+      "Microsoft.Testing.Extensions.TrxReport": {
+        "type": "Direct",
+        "requested": "[2.3.3, )",
+        "resolved": "2.3.3",
+        "contentHash": "vYBqGSlT94B8d6d4PRdPQ83ogn3kK4kXcnI3SlHBHZu1XsU01IDTMnWoto5v5wXN/Mz4XsVM3Do/sJdGRgH29g==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.3.3",
+          "Microsoft.Testing.Platform": "2.3.3"
+        }
+      },
+      "xunit.v3.mtp-v2": {
+        "type": "Direct",
+        "requested": "[4.0.1, )",
+        "resolved": "4.0.1",
+        "contentHash": "s88KiWwDDYgOWV3A+ViJiqCe9cLU/Rt6Gb5TfOC7Abv/HKSoj4IHVPcOQk7jPt7HhZHHEts5IuaVpB30eO5B1w==",
+        "dependencies": {
+          "xunit.analyzers": "2.1.0",
+          "xunit.v3.assert": "[4.0.1]",
+          "xunit.v3.core.mtp-v2": "[4.0.1]"
+        }
+      },
+      "Microsoft.ApplicationInsights": {
+        "type": "Transitive",
+        "resolved": "2.23.0",
+        "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw=="
+      },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg=="
+      },
+      "Microsoft.Testing.Extensions.Telemetry": {
+        "type": "Transitive",
+        "resolved": "2.4.0",
+        "contentHash": "JeP1RFqBa11fWmBk8xEfZcMKr4rxWSyI6OZ+659V069CaMkTEOQBW2UdSSeNz3absOsygcn7JJkzerC4LGnZ9w==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.23.0",
+          "Microsoft.Testing.Platform": "[2.4.0, 3.0.0)"
+        }
+      },
+      "Microsoft.Testing.Extensions.TrxReport.Abstractions": {
+        "type": "Transitive",
+        "resolved": "2.4.0",
+        "contentHash": "uRb+4qM42dFDg4kWJZ2kFEcwESNVCRZJjItp5vETorN3rSJGysP617LqYirOcrCYmxg+obPreHMM5JcsNDKtBw==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "[2.4.0, 3.0.0)"
+        }
+      },
+      "Microsoft.Testing.Platform": {
+        "type": "Transitive",
+        "resolved": "2.4.0",
+        "contentHash": "dp1N3P1ujb0ztwFgqz2o/ItEvq+pm19/AiA+Xq7Zpcy7oPMcxDBZLYGtf0LlU1MveEBJuKVjZhI+LnkfcH/0jQ=="
+      },
+      "Microsoft.Testing.Platform.MSBuild": {
+        "type": "Transitive",
+        "resolved": "2.4.0",
+        "contentHash": "qr5M6h16YHMJLFDcWELFVMMpGte2BUmveBZKT5YoBV+bmuJRPu9bv/Zqke4yQuOEKRNxoAETrG5jr+/6Rnr3Hg==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "[2.4.0, 3.0.0)"
+        }
+      },
+      "Microsoft.Win32.Registry": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg=="
+      },
+      "System.Security.AccessControl": {
+        "type": "Transitive",
+        "resolved": "6.0.1",
+        "contentHash": "IQ4NXP/B3Ayzvw0rDQzVTYsCKyy0Jp9KI6aYcK7UnGVlR9+Awz++TIPCQtPYfLJfOpm8ajowMR09V7quD3sEHw=="
+      },
+      "xunit.analyzers": {
+        "type": "Transitive",
+        "resolved": "2.1.0",
+        "contentHash": "X7QXEcZQGz0G/HL4HUyK+aAvNa/IMGbOCnFIq4jD/Evktq12xANKwzOUr7b08vCmC1LXu/47qHWOdjm3KfaJ0A=="
+      },
+      "xunit.v3.assert": {
+        "type": "Transitive",
+        "resolved": "4.0.1",
+        "contentHash": "nC7d3cY06Oo7hkdwWPZkBR0Ud75xNhgx0P7i0GmMMZC3puCGlc4szFiT30biH03IN/eDnr8h+nv3A1UD17bk/A=="
+      },
+      "xunit.v3.common": {
+        "type": "Transitive",
+        "resolved": "4.0.1",
+        "contentHash": "Qf25TVdadDQYf9zVxSd7L9RNQhuP0jCUHmo96XTmIKLxGefylIEV63jRbXBPFzdXmV09TCdcurk+AQ9LiWS2Hg==",
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
+        }
+      },
+      "xunit.v3.core.mtp-v2": {
+        "type": "Transitive",
+        "resolved": "4.0.1",
+        "contentHash": "7qfTfrIfS2wybpSVyRLmhXHbSudD2eNw66LfukixmKsRCTcfvOrLsx0qGL/lObcEh3Z2F4SIXgoFnLIiB8yfjQ==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.Telemetry": "2.4.0",
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.0",
+          "Microsoft.Testing.Platform": "2.4.0",
+          "Microsoft.Testing.Platform.MSBuild": "2.4.0",
+          "xunit.v3.extensibility.core": "[4.0.1]",
+          "xunit.v3.runner.inproc.console": "[4.0.1]"
+        }
+      },
+      "xunit.v3.extensibility.core": {
+        "type": "Transitive",
+        "resolved": "4.0.1",
+        "contentHash": "J0d5OfFcp920nZxCRIvU14+TZhiSPQR0wvqEMZ3MRiJLPu1VmYlcRNkmcSW0i1DwkB81gAHc+fHUQf/cU64MYg==",
+        "dependencies": {
+          "xunit.v3.common": "[4.0.1]"
+        }
+      },
+      "xunit.v3.runner.common": {
+        "type": "Transitive",
+        "resolved": "4.0.1",
+        "contentHash": "p9AyfBpj2e5Iws8B57SbLiSngg7mEdvegHInKR4T2cjt2mis9h8htVgCnmu//agZO4zri6p6VQOj5EkHHTy3gA==",
+        "dependencies": {
+          "Microsoft.Win32.Registry": "[5.0.0]",
+          "System.Security.AccessControl": "[6.0.1]",
+          "xunit.v3.common": "[4.0.1]"
+        }
+      },
+      "xunit.v3.runner.inproc.console": {
+        "type": "Transitive",
+        "resolved": "4.0.1",
+        "contentHash": "Hqwfd6ehMIhPmVWUQ2dgmknzuLFTWeyp8ES1q3D4YR5bQVyiXDcaIoaFwqAz2zgLr49WaW4Mz7VVncP7u/Q8/Q==",
+        "dependencies": {
+          "xunit.v3.extensibility.core": "[4.0.1]",
+          "xunit.v3.runner.common": "[4.0.1]"
+        }
+      },
+      "codeme.scaffoldcs.templates": {
+        "type": "Project",
+        "dependencies": {
+          "CodeMe.Basics": "[0.0.3, )"
+        }
+      },
+      "CodeMe.Basics": {
+        "type": "CentralTransitive",
+        "requested": "[0.0.3, )",
+        "resolved": "0.0.3",
+        "contentHash": "nNgoT45Ta8mefmm+6nh6jOVdqa2+FIirsCAYQZNsJEBGPSaenBnunh3ezhCZD1kaV+fvW+a5ybAWWlYiyem47Q=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.UnitTests/TemplateTests.cs b/tests/CodeMe.ScaffoldCS.UnitTests/TemplateTests.cs
new file mode 100644
index 0000000..f4dc7fc
--- /dev/null
+++ b/tests/CodeMe.ScaffoldCS.UnitTests/TemplateTests.cs
@@ -0,0 +1,11 @@
+namespace CodeMe.ScaffoldCS.UnitTests;
+
+public class TemplateTests
+{
+
+    [Fact]
+    public void TestScenario_ShouldBeExpected()
+    {
+        Console.WriteLine("@");
+    }
+}
\ No newline at end of file
diff --git a/tests/CodeMe.ScaffoldCS.UnitTests/packages.lock.json b/tests/CodeMe.ScaffoldCS.UnitTests/packages.lock.json
index 11823c8..dc5a884 100644
--- a/tests/CodeMe.ScaffoldCS.UnitTests/packages.lock.json
+++ b/tests/CodeMe.ScaffoldCS.UnitTests/packages.lock.json
@@ -20,13 +20,13 @@
       },
       "xunit.v3.mtp-v2": {
         "type": "Direct",
-        "requested": "[3.2.2, )",
-        "resolved": "3.2.2",
-        "contentHash": "S0LJpeMIMrmbVLXDCvPVX47OLk28qBYfGU+5SNCbarOEdw8oKLfiVqaACwuYRvLiOqDEB/+VJ8gTSB1ZwheoOQ==",
+        "requested": "[4.0.1, )",
+        "resolved": "4.0.1",
+        "contentHash": "s88KiWwDDYgOWV3A+ViJiqCe9cLU/Rt6Gb5TfOC7Abv/HKSoj4IHVPcOQk7jPt7HhZHHEts5IuaVpB30eO5B1w==",
         "dependencies": {
-          "xunit.analyzers": "1.27.0",
-          "xunit.v3.assert": "[3.2.2]",
-          "xunit.v3.core.mtp-v2": "[3.2.2]"
+          "xunit.analyzers": "2.1.0",
+          "xunit.v3.assert": "[4.0.1]",
+          "xunit.v3.core.mtp-v2": "[4.0.1]"
         }
       },
       "Microsoft.ApplicationInsights": {
@@ -41,32 +41,32 @@
       },
       "Microsoft.Testing.Extensions.Telemetry": {
         "type": "Transitive",
-        "resolved": "2.0.2",
-        "contentHash": "H580BvHyuADoWzlH9zRk5fqVyGucm6mhph+k40CQc9O4ie+Buxa4Pk9Q92BEClqIICqi25J7fuMII9qFYYgKtw==",
+        "resolved": "2.4.0",
+        "contentHash": "JeP1RFqBa11fWmBk8xEfZcMKr4rxWSyI6OZ+659V069CaMkTEOQBW2UdSSeNz3absOsygcn7JJkzerC4LGnZ9w==",
         "dependencies": {
           "Microsoft.ApplicationInsights": "2.23.0",
-          "Microsoft.Testing.Platform": "2.0.2"
+          "Microsoft.Testing.Platform": "[2.4.0, 3.0.0)"
         }
       },
       "Microsoft.Testing.Extensions.TrxReport.Abstractions": {
         "type": "Transitive",
-        "resolved": "2.3.3",
-        "contentHash": "dceVNxnfTEjKnrIreLcMfkgrzzBY8kgCCJX5NAv7Lq/6vPlTP4VB5zxKeuYy0yfCoBtWuPkLjUG6qtOBMfpypA==",
+        "resolved": "2.4.0",
+        "contentHash": "uRb+4qM42dFDg4kWJZ2kFEcwESNVCRZJjItp5vETorN3rSJGysP617LqYirOcrCYmxg+obPreHMM5JcsNDKtBw==",
         "dependencies": {
-          "Microsoft.Testing.Platform": "2.3.3"
+          "Microsoft.Testing.Platform": "[2.4.0, 3.0.0)"
         }
       },
       "Microsoft.Testing.Platform": {
         "type": "Transitive",
-        "resolved": "2.3.3",
-        "contentHash": "ENbH4BQh9riXtOKc25KKITfiGGWhWMBJA7pZuNaF9zxzzSaVkp5AMeZxGQ6sXYaR6xb724NLz985Is6XIYqLSg=="
+        "resolved": "2.4.0",
+        "contentHash": "dp1N3P1ujb0ztwFgqz2o/ItEvq+pm19/AiA+Xq7Zpcy7oPMcxDBZLYGtf0LlU1MveEBJuKVjZhI+LnkfcH/0jQ=="
       },
       "Microsoft.Testing.Platform.MSBuild": {
         "type": "Transitive",
-        "resolved": "2.0.2",
-        "contentHash": "2zKkQKaUoaKgb/3AekboWOdLMh4upCo1nLWQnjGzp8r9YjiNOZRrzTsJQ3A4U03AcbH0evlIvFDKYSUqmTVuug==",
+        "resolved": "2.4.0",
+        "contentHash": "qr5M6h16YHMJLFDcWELFVMMpGte2BUmveBZKT5YoBV+bmuJRPu9bv/Zqke4yQuOEKRNxoAETrG5jr+/6Rnr3Hg==",
         "dependencies": {
-          "Microsoft.Testing.Platform": "2.0.2"
+          "Microsoft.Testing.Platform": "[2.4.0, 3.0.0)"
         }
       },
       "Microsoft.Win32.Registry": {
@@ -74,65 +74,86 @@
         "resolved": "5.0.0",
         "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg=="
       },
+      "System.Security.AccessControl": {
+        "type": "Transitive",
+        "resolved": "6.0.1",
+        "contentHash": "IQ4NXP/B3Ayzvw0rDQzVTYsCKyy0Jp9KI6aYcK7UnGVlR9+Awz++TIPCQtPYfLJfOpm8ajowMR09V7quD3sEHw=="
+      },
       "xunit.analyzers": {
         "type": "Transitive",
-        "resolved": "1.27.0",
-        "contentHash": "y/pxIQaLvk/kxAoDkZW9GnHLCEqzwl5TW0vtX3pweyQpjizB9y3DXhb9pkw2dGeUqhLjsxvvJM1k89JowU6z3g=="
+        "resolved": "2.1.0",
+        "contentHash": "X7QXEcZQGz0G/HL4HUyK+aAvNa/IMGbOCnFIq4jD/Evktq12xANKwzOUr7b08vCmC1LXu/47qHWOdjm3KfaJ0A=="
       },
       "xunit.v3.assert": {
         "type": "Transitive",
-        "resolved": "3.2.2",
-        "contentHash": "BPciBghgEEaJN/JG00QfCYDfEfnLgQhfnYEy+j1izoeHVNYd5+3Wm8GJ6JgYysOhpBPYGE+sbf75JtrRc7jrdA=="
+        "resolved": "4.0.1",
+        "contentHash": "nC7d3cY06Oo7hkdwWPZkBR0Ud75xNhgx0P7i0GmMMZC3puCGlc4szFiT30biH03IN/eDnr8h+nv3A1UD17bk/A=="
       },
       "xunit.v3.common": {
         "type": "Transitive",
-        "resolved": "3.2.2",
-        "contentHash": "Hj775PEH6GTbbg0wfKRvG2hNspDCvTH9irXhH4qIWgdrOSV1sQlqPie+DOvFeigsFg2fxSM3ZAaaCDQs+KreFA==",
+        "resolved": "4.0.1",
+        "contentHash": "Qf25TVdadDQYf9zVxSd7L9RNQhuP0jCUHmo96XTmIKLxGefylIEV63jRbXBPFzdXmV09TCdcurk+AQ9LiWS2Hg==",
         "dependencies": {
           "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
         }
       },
       "xunit.v3.core.mtp-v2": {
         "type": "Transitive",
-        "resolved": "3.2.2",
-        "contentHash": "zW82tdCm+T1uUD1JKE+SmhgMq8nCAvcFPRLIVEiRgaxBSjcyJEKopLU3bHGOa416q+N3Dz7m1zLoPR5VJ5OQ+Q==",
+        "resolved": "4.0.1",
+        "contentHash": "7qfTfrIfS2wybpSVyRLmhXHbSudD2eNw66LfukixmKsRCTcfvOrLsx0qGL/lObcEh3Z2F4SIXgoFnLIiB8yfjQ==",
         "dependencies": {
-          "Microsoft.Testing.Extensions.Telemetry": "2.0.2",
-          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.0.2",
-          "Microsoft.Testing.Platform": "2.0.2",
-          "Microsoft.Testing.Platform.MSBuild": "2.0.2",
-          "xunit.v3.extensibility.core": "[3.2.2]",
-          "xunit.v3.runner.inproc.console": "[3.2.2]"
+          "Microsoft.Testing.Extensions.Telemetry": "2.4.0",
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.0",
+          "Microsoft.Testing.Platform": "2.4.0",
+          "Microsoft.Testing.Platform.MSBuild": "2.4.0",
+          "xunit.v3.extensibility.core": "[4.0.1]",
+          "xunit.v3.runner.inproc.console": "[4.0.1]"
         }
       },
       "xunit.v3.extensibility.core": {
         "type": "Transitive",
-        "resolved": "3.2.2",
-        "contentHash": "srY8z/oMPvh/t8axtO2DwrHajhFMH7tnqKildvYrVQIfICi8fOn3yIBWkVPAcrKmHMwvXRJ/XsQM3VMR6DOYfQ==",
+        "resolved": "4.0.1",
+        "contentHash": "J0d5OfFcp920nZxCRIvU14+TZhiSPQR0wvqEMZ3MRiJLPu1VmYlcRNkmcSW0i1DwkB81gAHc+fHUQf/cU64MYg==",
         "dependencies": {
-          "xunit.v3.common": "[3.2.2]"
+          "xunit.v3.common": "[4.0.1]"
         }
       },
       "xunit.v3.runner.common": {
         "type": "Transitive",
-        "resolved": "3.2.2",
-        "contentHash": "/hkHkQCzGrugelOAehprm7RIWdsUFVmIVaD6jDH/8DNGCymTlKKPTbGokD5czbAfqfex47mBP0sb0zbHYwrO/g==",
+        "resolved": "4.0.1",
+        "contentHash": "p9AyfBpj2e5Iws8B57SbLiSngg7mEdvegHInKR4T2cjt2mis9h8htVgCnmu//agZO4zri6p6VQOj5EkHHTy3gA==",
         "dependencies": {
           "Microsoft.Win32.Registry": "[5.0.0]",
-          "xunit.v3.common": "[3.2.2]"
+          "System.Security.AccessControl": "[6.0.1]",
+          "xunit.v3.common": "[4.0.1]"
         }
       },
       "xunit.v3.runner.inproc.console": {
         "type": "Transitive",
-        "resolved": "3.2.2",
-        "contentHash": "ulWOdSvCk+bPXijJZ73bth9NyoOHsAs1ZOvamYbCkD4DNLX/Bd29Ve2ZNUwBbK0MqfIYWXHZViy/HKrdEC/izw==",
+        "resolved": "4.0.1",
+        "contentHash": "Hqwfd6ehMIhPmVWUQ2dgmknzuLFTWeyp8ES1q3D4YR5bQVyiXDcaIoaFwqAz2zgLr49WaW4Mz7VVncP7u/Q8/Q==",
         "dependencies": {
-          "xunit.v3.extensibility.core": "[3.2.2]",
-          "xunit.v3.runner.common": "[3.2.2]"
+          "xunit.v3.extensibility.core": "[4.0.1]",
+          "xunit.v3.runner.common": "[4.0.1]"
         }
       },
       "codeme.scaffoldcs": {
-        "type": "Project"
+        "type": "Project",
+        "dependencies": {
+          "CodeMe.ScaffoldCS.Templates": "[1.0.0, )"
+        }
+      },
+      "codeme.scaffoldcs.templates": {
+        "type": "Project",
+        "dependencies": {
+          "CodeMe.Basics": "[0.0.3, )"
+        }
+      },
+      "CodeMe.Basics": {
+        "type": "CentralTransitive",
+        "requested": "[0.0.3, )",
+        "resolved": "0.0.3",
+        "contentHash": "nNgoT45Ta8mefmm+6nh6jOVdqa2+FIirsCAYQZNsJEBGPSaenBnunh3ezhCZD1kaV+fvW+a5ybAWWlYiyem47Q=="
       }
     }
   }