diff --git a/documentation/TemplateEngine/Available-Symbols-Generators.md b/documentation/TemplateEngine/Available-Symbols-Generators.md
new file mode 100644
index 000000000000..1d47d8234d7b
--- /dev/null
+++ b/documentation/TemplateEngine/Available-Symbols-Generators.md
@@ -0,0 +1,657 @@
+Inside the `template.json` file, you can define custom symbols that will be used inside the template files.
+The supported symbol types are:
+- Parameter - the value is typically provided by the user when creating the template. If not provided, the value is taken from host configuration, otherwise default value is used.
+- Derived - defines transformation of another symbol. The value of this symbol is derived from the value of another symbol by applying the defined form.
+- Computed - the boolean value is evaluated during the processing of the template based on the other symbol values.
+- Generated - the value is computed by a built-in symbol value generator.
+There are no restrictions on symbol order: e.g. generated/computed/derived symbols can be used in any type of other symbols. The only rule is in avoiding circular dependencies such as:
+```json
+"symbols": {
+ "switchCheck": {
+ "type": "generated",
+ "generator": "switch",
+ "datatype": "string",
+ "parameters": {
+ "evaluator": "C++",
+ "cases": [
+ {
+ "condition": "(switchCheck2 == 'regions')",
+ "value": "regions"
+ }
+ ]
+ }
+ },
+ "switchCheck2": {
+ "type": "generated",
+ "generator": "switch",
+ "datatype": "string",
+ "parameters": {
+ "evaluator": "C++",
+ "cases": [
+ {
+ "condition": "(switchCheck == 'regions')",
+ "value": "regions"
+ }
+ ]
+ }
+ }
+```
+This article covers available generators for generated symbols.
+
+To use a generated symbol inside your `template.json` file:
+1. Add `"type": "generated"` to the symbol definition
+1. Use the `"generator": ...` parameter to select the generator to use.
+This is a sample of definition of a generated symbol, the `port` generator, that generates a random number for an http port.
+
+```json
+"IISExpressPortGenerated": {
+ "type": "generated",
+ "generator": "port",
+ "parameters": {
+ "fallback":"5000"
+ }
+},
+```
+
+Most of the generators need to be configured via parameters that let you select the source of the data and select among the options available. Below is a sample of a symbol that uses the `now` generator to replace a fixed year indication present in the source files with the current year.
+
+```json
+"copyrightYear": {
+ "type": "generated",
+ "generator": "now",
+ "replaces": "1975",
+ "parameters": {
+ "format": "yyyy"
+ }
+},
+```
+
+Available built-in generators for computing generated symbols values are:
+
+| Name | Description |
+|----------|---------------|
+| [casing](#casing) | Enables changing the casing of a string. |
+| [coalesce](#coalesce) | Behaves like the C# `??` operator. |
+| [constant](#constant) | Constant value |
+| [port](#port) | Generate a port number that can be used by web projects. |
+| [guid](#guid) | Create a new guid. |
+| [now](#now) | Get the current date/time. |
+| [random](#random) | Generate random int. |
+| [regex](#regex) | Process a regular expression. |
+| [regexMatch](#regexmatch) | Checks if the value matches the regex pattern. |
+| [switch](#switch) | Behaves like a C# `switch` statement. |
+| [join](#join) | Concatenates multiple symbols or constants. |
+
+## Casing
+Changes the case of the text of the source value to all upper-case or all lower-case. It does not affect spaces (i.e. does not do any sort of Camel Casing).
+
+#### Parameters
+| Name |Data Type| Description |Mandatory|
+|----------|------|---------------|---|
+|`source`|`string`| The name of symbol to use as the source of data.| yes |
+|`toLower`|`bool`| applies lower case if `true`, upper case otherwise| no |
+
+### Samples
+
+In this sample three symbols are defined:
+ - `ownerName` is a parameter which can be set on the command line using `dotnet new` It has a default value of "John Doe", that will be used if the no value is received from the host. The value will be used to replace "John Smith (a)".
+ - `nameUpper` and `nameLower` are the symbols that generate the upperCase and lowerCase version of `ownerName` that are used to replace any instance of "John Smith (U)" and "John Smith (l)".
+
+```json
+"symbols":{
+ "ownerName":{
+ "type": "parameter",
+ "datatype":"text",
+ "replaces": "John Smith (a)",
+ "defaultValue": "John Doe"
+ },
+
+ "nameUpper":{
+ "type": "generated",
+ "generator": "casing",
+ "parameters": {
+ "source":"ownerName",
+ "toLower": false
+ },
+ "replaces":"John Smith (U)"
+ },
+
+ "nameLower":{
+ "type": "generated",
+ "generator": "casing",
+ "parameters": {
+ "source":"ownerName",
+ "toLower": true
+ },
+ "replaces":"John Smith (l)"
+ }
+}
+```
+
+### Related
+
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/CaseChangeMacro.cs)
+[`Sample`](https://github.com/dotnet/dotnet-template-samples/tree/master/11-change-string-casing)
+
+
+## Coalesce
+Behaves like the C# `??` operator. Note: the empty string value and default value of value type is treated as `null`.
+The typical use of this generator is to check if the parameter was provided by user, otherwise set fallback generated value.
+
+#### Parameters
+
+|Name|Data Type|Description|Mandatory|
+|---|---|---|---|
+|`sourceVariableName`|`string`|the symbol name which is a primary source of data (left operand of `coalesce`)|yes|
+|`fallbackVariableName`|`string`|the symbol name which is an alternate source of data(right operand of `coalesce`)|yes|
+|`defaultValue`|`string`|The default value. In case it is specified, and primary source is equal to this value, the fallback value will be used.|no|
+
+### Samples
+
+In this sample three symbols are defined:
+ - `MessageYear` - is a parameter set by the user when calling `dotnet new`.
+ - `ThisYear` - use the now generator to calculate the current year.
+ - `YearReplacer` - ensures that any occurrence of "1234" is replaced. If `MessageYear` was passed in by the user that value will be used. Otherwise `ThisYear` will be used.
+
+```json
+ "symbols":{
+ "MessageYear":{
+ "type": "parameter",
+ "datatype":"int"
+ },
+ "ThisYear":{
+ "type": "generated",
+ "generator": "now",
+ "parameters": {
+ "format": "yyyy"
+ }
+ },
+ "YearReplacer": {
+ "type": "generated",
+ "generator": "coalesce",
+ "parameters": {
+ "sourceVariableName": "MessageYear",
+ "fallbackVariableName": "ThisYear"
+ },
+ "replaces": "1234"
+ }
+ }
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/CoalesceMacro.cs)
+
+## Constant
+
+Uses constant value.
+
+#### Parameters
+
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`value`|`string`|constant value|yes|
+
+
+### Samples
+
+`myConstant` is a symbol that replaces "1234" with "5001"
+
+```json
+"symbols":{
+ "myConstant": {
+ "type": "generated",
+ "generator": "constant",
+ "parameters": {
+ "value":"5001"
+ },
+ "replaces":"1234"
+ }
+}
+```
+
+### Related
+
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/ConstantMacro.cs)
+[`Sample`](https://github.com/dotnet/dotnet-template-samples/tree/master/13-constant-value)
+
+
+## Port
+Gets an available port number on the machine.
+During evaluation looks for a valid free port number trying to create a socket, and in case of problems, returns the value defined in the `fallback` parameter.
+
+#### Parameters
+
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`high`|`integer`|defined the high bound of range to select port from. The maximum value is `65535`. If greater value is specified, `65535` is used instead. |no, default: `65535`|
+|`low`|`integer`|defined the low bound of range to select port from. The minimum value is `1024`. If less value is specified, `1024` is used instead.|no, default: `1024`|
+|`fallback`|`integer`|fallback value|no, default: `0`|
+
+Note: if `low` > `high`, the default values for `low` and `high` are used: 1024 - 65535.
+
+The following ports are reserved:
+- 1719 - H323 (RAS)
+- 1720 - H323 (Q931)
+- 1723 - H323 (H245)
+- 2049 - NFS
+- 3659 - apple-sasl / PasswordServer [Apple addition]
+- 4045 - lockd
+- 4190 - ManageSieve [Apple addition]
+- 5060 - SIP
+- 5061 - SIPS
+- 6000 - X11
+- 6566 - SANE
+- 6665 - Alternate IRC [Apple addition]
+- 6666 - Alternate IRC [Apple addition]
+- 6667 - Standard IRC [Apple addition]
+- 6668 - Alternate IRC [Apple addition]
+- 6669 - Alternate IRC [Apple addition]
+- 6679 - Alternate IRC SSL [Apple addition]
+- 6697 - IRC+SSL [Apple addition]
+- 10080 - amanda
+
+### Samples
+In this sample `KestrelPortGenerated` is a symbol that return the number of an available port or 5000.
+
+```json
+ "KestrelPortGenerated": {
+ "type": "generated",
+ "generator": "port"
+ "parameters": {
+ "fallback":"5000"
+ }
+ },
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/GeneratePortNumberMacro.cs)
+
+
+## Guid
+
+*Note:* [Guids section in `template.json`](Reference-for-template.json.md#guids) can be used to achieve same goals with easier configuration
+
+Creates a formatted guid for a replacement. To configure the output format of the macro you can use the **defaultFormat** parameter that accepts a single value from **{'n', 'd', 'b', 'p', 'x'}** for lowercase output or **{'N', 'D', 'B', 'P', 'X'}** for uppercase output. The formats are defined in [`Guid.ToString()` method documentation](https://msdn.microsoft.com/en-us/library/97af8hh4(v=vs.110).aspx)
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`defaultFormat`|`string`|format descriptor|no, default: `D`|
+
+### Samples
+This sample creates different symbols showing the different formatting available for the generated guid.
+
+```json
+"symbols":{
+ "id01":{
+ "type": "generated",
+ "generator": "guid",
+ "replaces": "myid01",
+ "parameters": {
+ "defaultFormat":"N"
+ }
+ },
+ "id02":{
+ "type": "generated",
+ "generator": "guid",
+ "replaces": "myid02",
+ "parameters": {
+ "defaultFormat":"D"
+ }
+ },
+ "id03":{
+ "type": "generated",
+ "generator": "guid",
+ "replaces": "myid03",
+ "parameters": {
+ "defaultFormat":"B"
+ }
+ },
+ "id04":{
+ "type": "generated",
+ "generator": "guid",
+ "replaces": "myid04",
+ "parameters": {
+ "defaultFormat":"P"
+ }
+ },
+ "id05":{
+ "type": "generated",
+ "generator": "guid",
+ "replaces": "myid05",
+ "parameters": {
+ "defaultFormat":"X"
+ }
+ }
+}
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/GuidMacro.cs)
+[`Guid Format Documentation`](https://msdn.microsoft.com/en-us/library/97af8hh4(v=vs.110).aspx)
+[Guids section in `template.json`](Reference-for-template.json.md#guids)
+
+
+## Now
+
+Creates a symbol from the current date/time.
+
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`format`|`string`|[`DateTime.ToString()`](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings) format|no|
+|`utc`|`bool`|UTC time if `true`, local time otherwise|no|
+
+### Samples
+In this sample a symbol is created showing the current data, and replacing any instance of "01/01/1999"
+
+```json
+"symbols":{
+ "createdDate": {
+ "type": "generated",
+ "generator": "now",
+ "parameters": {
+ "format": "MM/dd/yyyy"
+ },
+ "replaces":"01/01/1999"
+ }
+}
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/NowMacro.cs)
+[`DateTime.ToString documentation`](https://msdn.microsoft.com/en-us/library/zdtaw1bw(v=vs.110).aspx)
+[`Sample`](https://github.com/dotnet/dotnet-template-samples/tree/master/10-symbol-from-date)
+
+## Random
+
+Creates a random integer value in a specified range.
+
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`low`|`integer`|lower inclusive bound|yes|
+|`high`|`integer`|upper exclusive bound|no, default:`int.MaxValue`|
+
+### Samples
+This sample shows a symbol that generates a value from `0` to `10000` excluded, and replace any instance of `4321`
+
+```json
+"symbols":{
+ "myRandomNumber":{
+ "type": "generated",
+ "generator": "random",
+ "parameters": {
+ "low": 0,
+ "high": 10000
+ },
+ "replaces": "4321"
+ }
+}
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/RandomMacro.cs)
+[`Sample`](https://github.com/dotnet/dotnet-template-samples/tree/master/12-random-number)
+
+
+## Regex
+Defines a list of data manipulation steps based on regex expressions.
+
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`source`|`string`|the symbol to transform|yes|
+|`steps`|`array`|replacement steps|yes|
+
+`steps` element definition:
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`regex`|`string`, regex pattern|selection pattern|yes|
+|`replacement`|`string`|the replacement value for matched pattern|yes|
+
+### Samples
+
+```json
+"symbols": {
+ "regexExample": {
+ "type": "generated",
+ "generator": "regex",
+ "dataType": "string",
+ "replaces": "A different message", //The value to replace in the output
+ "parameters": {
+ "source": "message", //The name of the symbol whose value should be operated on
+ "steps": [
+ {
+ "regex": "^test", //The regular expression whose matches will be replaced with '[Replaced]`
+ "replacement": "[Replaced]" //The value to replace matches of the expression '^test' with
+ },
+ {
+ "regex": "test$",
+ "replacement": "[/Replaced]"
+ }
+ ]
+ }
+ }
+}
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/RegexMacro.cs)
+[`RegEx.Replace Documentation`](https://msdn.microsoft.com/en-us/library/xwewhkd1(v=vs.110).aspx)
+
+## RegexMatch
+Tries to match regex pattern against value of source symbol and returns `true` if matched, otherwise `false`.
+
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`source`|`string`|the symbol to attempt to match value|yes|
+|`pattern`|`string`, regex pattern|the regex match pattern|yes|
+
+### Samples
+
+```json
+"symbols": {
+ "isMatch": {
+ "type": "generated",
+ "generator": "regexMatch",
+ "dataType": "bool",
+ "replaces": "test.value1",
+ "parameters": {
+ "source": "name",
+ "pattern": "^hello$"
+ }
+ }
+}
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/RegexMatchMacro.cs)
+[`Regex.IsMatch Documentation`](https://docs.microsoft.com/en-us/dotnet/api/system.text.regularexpressions.regex.ismatch)
+
+## Switch
+
+Defines a set of conditions to be evaluated, and the value to return if the condition is met. The first condition to evaluate to true is used. To include a default case, add a condition that always evaluates to true as the last entry in `cases`.
+
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`cases`|`array`|choices to evaluate|yes|
+|`evaluator`|`enum`: `C++2`, `C++`, `MSBuild`, `VB`|expression evaluation engine|no, default: `C++2`|
+
+`cases` definition
+|Name|Data Type|Description|Mandatory|
+|----------|------|---------------|---|
+|`condition`|`string`|the condition to evaluate, keep empty for default clause.|no|
+|`value`|`string`|the value to return, if `condition` evaluates to `true`|yes|
+
+### Samples
+
+This sample shows how to change the replacement value based on evaluating conditions using other symbols:
+
+```json
+"symbols": {
+ "test": {
+ "type": "parameter",
+ "datatype": "string"
+ },
+ "example": {
+ "type": "generated",
+ "generator": "switch",
+ "replaces": "abc",
+ "parameters": {
+ "evaluator": "C++",
+ "datatype": "string",
+ "cases": [
+ {
+ "condition": "(test == '123')",
+ "value": "456"
+ },
+ {
+ "condition": "(test == '789')",
+ "value": "012"
+ }
+ ]
+ }
+ }
+}
+```
+In this case, if the user enters the value `123` as the value of the parameter `test`, `abc` in the content will be replaced with `456`, if the user enters `789`, `abc` is replaced with `012` instead.
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/SwitchMacro.cs)
+
+## Join
+
+Concatenates multiple symbols or constants with the defined separator into a new symbol.
+
+#### Parameters
+|Name|Data Type|Description|Mandatory|
+|----------|---------|----------|-----|
+|`symbols` |`array` |defines the values to concatenate|yes|
+|`separator` |`string` |the value used as the separator between the values to be concatenated, notice that you can use `/` as folder separator also on Windows, since File API will convert it into `\` | no |
+|`removeEmptyValues` |`bool`|indicates whether the empty values should be skipped or honored. By default this switch is off - leading to multiple consecutive separators in output string in case that same input values are null or empty| no |
+
+`symbols` definition
+|Name|Data Type|Description|Mandatory|
+|------|---------|---------------|---|
+|`type` |`enum`: `ref`, `const` |`ref` indicates that the value is referenced from another symbol `const` - the value is a string constant|no, default: `const`|
+|`value` |`string` |either a name of another symbol or string constant|yes, should be not empty or whitespace when `type` is `ref`|
+
+### Samples
+
+This sample shows how to change the replacement value based on evaluating conditions using other symbols:
+
+```json
+"symbols": {
+ "company": {
+ "type": "parameter",
+ "dataType": "string",
+ "defaultValue": "Microsoft"
+ },
+ "product": {
+ "type": "parameter",
+ "dataType": "string",
+ "defaultValue": "Visual Studio"
+ },
+ "joinedRename": {
+ "type": "generated",
+ "generator": "join",
+ "fileRename": "Api",
+ "parameters": {
+ "symbols": [
+ {
+ "type": "const",
+ "value": "Source"
+ },
+ {
+ "type": "const",
+ "value": "Api"
+ },
+ {
+ "type": "ref",
+ "value": "company"
+ },
+ {
+ "type": "ref",
+ "value": "product"
+ }
+ ],
+ "separator": "/",
+ "removeEmptyValues": true
+ }
+ }
+}
+```
+This sample will rename folder called `Api` into `Source/Api/Microsoft/Visual Studio`. Notice that File API will automatically change `/` into `\` on Windows.
+
+Joining [multi-choice symbol](Reference-for-template.json.md#multichoice-symbols-specifics) values:
+
+`template.json`:
+```json
+"symbols": {
+ "Platform": {
+ "type": "parameter",
+ "description": "The target framework for the project.",
+ "datatype": "choice",
+ "allowMultipleValues": true,
+ "choices": [
+ {
+ "choice": "Windows",
+ "description": "Windows Desktop"
+ },
+ {
+ "choice": "WindowsPhone",
+ "description": "Windows Phone"
+ },
+ {
+ "choice": "MacOS",
+ "description": "Macintosh computers"
+ },
+ {
+ "choice": "iOS",
+ "description": "iOS mobile"
+ },
+ {
+ "choice": "android",
+ "description": "android mobile"
+ },
+ {
+ "choice": "nix",
+ "description": "Linux distributions"
+ }
+ ],
+ "defaultValue": "MacOS|iOS"
+ },
+ "joinedRename": {
+ "type": "generated",
+ "generator": "join",
+ "replaces": "SupportedPlatforms",
+ "parameters": {
+ "symbols": [
+ {
+ "type": "ref",
+ "value": "Platform"
+ }
+ ],
+ "separator": ", ",
+ "removeEmptyValues": true,
+ }
+ }
+}
+```
+
+`Program.cs`:
+```C#
+// This file is generated for platform: SupportedPlatforms
+```
+
+This sample will expand and join values of `Platform` argument and replace `SupportedPlatforms` string with `MacOS, iOS`:
+
+`Program.cs`:
+```C#
+// This file is generated for platform: MacOS, iOS
+```
+
+### Related
+[`Implementation class`](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/Macros/JoinMacro.cs)
diff --git a/documentation/TemplateEngine/Available-templates-for-dotnet-new.md b/documentation/TemplateEngine/Available-templates-for-dotnet-new.md
new file mode 100644
index 000000000000..042aad9077c6
--- /dev/null
+++ b/documentation/TemplateEngine/Available-templates-for-dotnet-new.md
@@ -0,0 +1,95 @@
+To search for the templates available on NuGet.org, use [`dotnet new search`](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-new-search).
+```
+ dotnet new search web
+ dotnet new search azure --type project
+ dotnet new search azure --author Microsoft
+```
+
+To ensure that the template package appears in `dotnet new search` result, set [the NuGet package type](https://docs.microsoft.com/en-us/nuget/create-packages/set-package-type) to `Template`.
+
+**Note:** In order to show templates preinstalled with SDK and installed manually run the [`dotnet new list`](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-new-list).
+
+```
+ dotnet new list
+ dotnet new list --author Microsoft
+ dotnet new list web
+ dotnet new list web --type project
+```
+
+Below is a list of selected NuGet.org templates which are available for use with `dotnet new`:
+
+# C# Templates
+
+
+| Name | Quick Install |
+|----------|:--------------|
+| [.NET Boxed](https://github.com/Dotnet-Boxed/Templates) | `dotnet new install "Boxed.Templates"`|
+| [Auth0 Templates](https://github.com/auth0/auth0-dotnet-templates) | `dotnet new install Auth0.Templates` |
+| [AWS Lambda .NET Core Templates](https://github.com/aws/aws-lambda-dotnet/tree/master/Blueprints) | `dotnet new install "Amazon.Lambda.Templates"`|
+| [Avalonia UI Templates](https://github.com/AvaloniaUI/Avalonia) - Avalonia is a framework for creating cross platform UI | `dotnet new install "Avalonia.Templates"`|
+| [Blazor](http://blazor.net) - Full stack web development with C# and WebAssembly | `dotnet new install "Microsoft.AspNetCore.Blazor.Templates::3.0.0-*"`|
+| [Cake.Frosting](https://github.com/cake-build/cake) | `dotnet new install "Cake.Frosting.Template"` |
+| [Carter](https://github.com/CarterCommunity/Carter) - Carter is a library that allows Nancy-esque routing for use with ASP.Net Core. | `dotnet new install "CarterTemplate"`|
+| [CleanBlazor](https://github.com/fvilches17/CleanBlazor) - Minimal Blazor projects. Standard Blazor project templates minus any boilerplate assets (e.g. Bootstrap, Counter.razor, etc.) | `dotnet new install "FriscoVInc.DotNet.Templates.CleanBlazor"` |
+| [cloudscribe](https://www.cloudscribe.com/docs/introduction) | `dotnet new install "cloudscribe.templates"` |
+| [DotVVM](https://github.com/riganti/dotvvm) - Open source MVVM framework for line of business web applications | `dotnet new install "DotVVM.Templates"` |
+| [Eto.Forms](https://github.com/picoe/Eto) | `dotnet new install "Eto.Forms.Templates"` |
+| [GCC.Build](https://github.com/roozbehid/dotnet-vcxproj) - C/C++/CPP/VCXPROJ Build Template using GCC/G++/EMCC or your favorate compiler | `dotnet new install GCC.Build.Template` |
+| [Geco](https://github.com/iQuarc/Geco) - C# 6 Interpolated strings based Code Generator | `dotnet new install "iQuarc.Geco.CSharp"` |
+| [GtkSharp](https://github.com/GtkSharp/GtkSharp) | `dotnet new install "GtkSharp.Template.CSharp"` |
+| [IdentityServer4.Templates](https://github.com/IdentityServer/IdentityServer4.Templates) | `dotnet new install "identityserver4.templates"` |
+| [Kentico Cloud Boilerplate](https://github.com/Kentico/cloud-boilerplate-net) | `dotnet new install "KenticoCloud.CloudBoilerplateNet"` |
+| [MonoGame (.NET Core)](https://github.com/MonoGame/MonoGame) | `dotnet new install "MonoGame.Templates.CSharp"` |
+| [MSBuild extension](https://github.com/tintoy/msbuild-extension-template) | `dotnet new install "MSBuildExtensionTemplate"` |
+| [MvxScaffolding Templates](https://github.com/Plac3hold3r/MvxScaffolding) - MvvmCross Xamarin native and Xamarin Forms templates. | `dotnet new install "MvxScaffolding.Templates"` |
+| [NancyFX Template](https://github.com/jchannon/NancyTemplate) | not on nuget.org |
+| [NSpec Templates](https://github.com/nspec/DotNetNewNSpec) | `dotnet new install "dotnet-new-nspec"` |
+| [NUnit 3 Test Project Template](https://github.com/nunit/dotnet-new-nunit) | `dotnet new install "NUnit3.DotNetNew.Template"` |
+| [Paulovich.Caju](https://github.com/ivanpaulovich/dotnet-new-caju) - .NET applications with Event Sourcing, Hexagonal or Clean Architectures styles | `dotnet new install "Paulovich.Caju"` |
+| [Paulovich.Manga](https://github.com/ivanpaulovich/manga-clean-architecture) - Clean Architecture for .NET Applications! | `dotnet new install "Paulovich.Manga"` |
+| [Particular Templates](https://docs.particular.net/nservicebus/dotnet-templates) - Templates targeting NServiceBus and other tools and libraries from [Particular Software](https://particular.net/) | `dotnet new install "ParticularTemplates"` |
+| [Pioneer Console Boilerplate](https://github.com/PioneerCode/pioneer-console-boilerplate) - Boilerplated .NET Core console application that includes dependency injection, logging and configuration. | `dotnet new install "Pioneer.Console.Boilerplate"` |
+| [PowerShell Core](https://github.com/tintoy/ps-core-module-template) | `dotnet new install "FiftyProtons.Templates.PSCore"` |
+| [Prism Forms QuickStarts](https://github.com/dansiegel/Prism-Templates) - Empty & QuickStart project Templates for Prism for Xamarin Forms. *Requires dotnet cli 2.0 pre3+* | `dotnet new install "Prism.Forms.QuickstartTemplates"` |
+| [Raspberry Pi 3](https://github.com/jeremylindsayni/RaspberryPiTemplate) - C# template for .NET Core 2 IoT applications. | `dotnet new install "RaspberryPi.Template"` |
+| [ServiceStack](https://github.com/NetCoreApps/templates) | `dotnet new install "ServiceStack.Core.Templates"` |
+| [SpecFlow.Templates.DotNet](https://github.com/SpecFlowOSS/SpecFlow) - A project template for creating executable specifications with SpecFlow. You can choose from different .NET frameworks and test frameworks. |`dotnet new install "SpecFlow.Templates.DotNet"` |
+| [Template templates](https://github.com/tintoy/dotnet-template-templates) - Templates to create new project and item templates. Requires `new3`. | `dotnet new install "FiftyProtons.Templates.DotNetNew"` |
+| [Zahasoft Templates](https://github.com/zahasoft/skele) | `dotnet new install "Zahasoft.Skele"` |
+| [ASP.NET Core Web API (extended)](https://github.com/popov1024/httpapi-template-sharp) | `dotnet new install "Popov1024.HttpApi.Template.CSharp"` |
+| [ASP.NET Core Web API for AKS](https://github.com/robbell/dotnet-aks-api-template) - A template for creating a fully-featured, 12 Factor, ASP.NET Core Web API for AKS | `dotnet new install "RobBell.AksApi.Template"` |
+| [HoNoSoFt.DotNet.Web.Spa.ProjectTemplates (VueJs + Picnic CSS)](https://github.com/Nordes/HoNoSoFt.DotNet.Web.Spa.ProjectTemplates) | `dotnet new install "HoNoSoFt.DotNet.Web.Spa.ProjectTemplates"` |
+| [xUnit Test Template](https://github.com/gatewayprogrammingschool/xUnit.Template) - Adds a xUnit test file to an existing test project. | `dotnet new install GatewayProgrammingSchool.xUnit.CSharp`|
+[RocketMod Plugin Templates](https://github.com/RocketMod/Rocket.Templates) RocketMod is a plugin framework for .NET based games. This template allows to quickly get started with a new RocketMod Plugin.| `dotnet new install "Rocket.Templates"` |
+| [EISK Web Api](https://github.com/eisk/eisk.webapi) - ASP.NET Core templates with simple use cases to build scalable web api with architectural best practices (DDD, Onion Architecture etc). | `dotnet new install "eisk.webapi"` |
+|[OpenMod Plugin Templates](https://github.com/openmod/openmod/tree/master/templates) - OpenMod is .NET plugin framework. These templates allow user to quickly get started with a new OpenMod Plugin.| `dotnet new install "OpenMod.Templates"` |
+
+# F# Templates
+
+| Name | Quick Install |
+|----------|:--------------|
+| [ASP.NET Core WebAPI F# Template](https://github.com/MNie/FSharpNetCoreWebApiTemplate) | `dotnet new install "WebAPI.FSharp.Template"` |
+| [Bolero: F# in WebAssembly](https://fsbolero.io/)| `dotnet new install Bolero.Templates`|
+| [Eto.Forms](https://github.com/picoe/Eto) | `dotnet new install "Eto.Forms.Templates"` |
+| [Expecto Template](https://github.com/MNie/Expecto.Template) | `dotnet new install "Expecto.Template"`|
+| [F# TypeProvider Template](https://github.com/fsprojects/FSharp.TypeProviders.SDK#the-f-type-provider-sdk)| `dotnet new install FSharp.TypeProviders.Templates`|
+| [Fable-elmish](https://github.com/fable-compiler/fable-elmish) | `dotnet new install "Fable.Template.Elmish.React"` |
+| [Fable, F# \|> Babel](http://fable.io) | `dotnet new install "Fable.Template"` |
+| [Fable Library](https://github.com/TheAngryByrd/Fable.Template.Library) - F# Template for creating and publishing Fable libraries | `dotnet new install "Fable.Template.Library"` |
+| [Fabulous for Xamarin.Forms](https://github.com/fsprojects/Fabulous/tree/master/Fabulous.XamarinForms)| `dotnet new install Fabulous.XamarinForms.Templates`|
+| [Freya](https://freya.io) | `dotnet new install "Freya.Template"` |
+| [Giraffe Template](https://github.com/giraffe-fsharp/giraffe-template) | `dotnet new install "giraffe-template"` |
+| [GtkSharp](https://github.com/GtkSharp/GtkSharp) | `dotnet new install "GtkSharp.Template.FSharp"` |
+| [Interstellar](https://github.com/fsprojects/Interstellar) | `dotnet new install "Interstellar.Template"` |
+| [MiniScaffold](https://github.com/TheAngryByrd/MiniScaffold) - F# Template for creating and publishing libraries targeting .NET Full (net45) and Core (netstandard1.6) | `dotnet new install "MiniScaffold"` |
+| [NancyFx](https://github.com/MNie/NancyFxCore)| `dotnet new install "NancyFx.Core.Template"`|
+| [SAFE Template](https://safe-stack.github.io/)| `dotnet new install "SAFE.Template"`|
+| [vbfox's F# Templates](https://github.com/vbfox/FSharpTemplates)| `dotnet new install "BlackFox.DotnetNew.FSharpTemplates"`|
+| [WebSharper](https://github.com/dotnet-websharper/core)| `dotnet new install "WebSharper.Templates"`
+
+# VBNet Templates
+
+| Name | Quick Install |
+|----------|:--------------|
+| [GtkSharp](https://github.com/GtkSharp/GtkSharp) | `dotnet new install "GtkSharp.Template.VBNet"` |
+| [InteXX Assorted Templates](https://github.com/InteXX/Templates) | `dotnet new install "Intexx.Templates"` |
diff --git a/documentation/TemplateEngine/Binding-and-project-context-evaluation.md b/documentation/TemplateEngine/Binding-and-project-context-evaluation.md
new file mode 100644
index 000000000000..8ba818f91dc3
--- /dev/null
+++ b/documentation/TemplateEngine/Binding-and-project-context-evaluation.md
@@ -0,0 +1,102 @@
+# Binding and project context evaluation
+
+## Overview
+
+Since .NET SDK 7.0.100 template engine supports binding of symbols to various external sources, including MSBuild properties of the current project.
+The feature is available for both `dotnet new` and Visual Studio.
+
+## `bind` symbols
+
+The symbol binds value from external sources.
+By default, the following sources are available:
+- host parameters - parameters defined at certain host. For .NET SDK the following parameters are defined: `HostIdentifier: dotnetcli`, `GlobalJsonExists: true/false`, `WorkingDirectory: `. Binding syntax is `host:`, example: `host:HostIdentifier`.
+- environment variables - allows to bind environment variables. Binding syntax is `env:`, example: `env:MYENVVAR`.
+
+It is also possible to bind the parameter without the prefix as a fallback behavior: `HostIdentifier`, `MYENVVAR`.
+
+The priority of the sources are following:
+- host parameters: 100
+- environment variables: 0
+
+The higher value indicates higher priority.
+
+
+|Name|Description|Mandatory|
+|---|---|---|
+|`type`|`bind`|yes|
+|`binding`| Mandatory. The name of the source and parameter in the source to take the value from. The syntax follows: `:`.|yes|
+|`replaces`|The text to be replaced by the symbol value in the template files content.|no|
+|`fileRename`|The portion of template filenames to be replaced by the symbol value.|no|
+|`defaultValue`|The value assigned to the symbol if no value was provided from external source(s). Recommended to be used when `replaces` and/or `fileRename` is used. In case default value is not specified and no value was provided from external source(s) the replacement won't be performed. |no|
+|`dataType`|The value assigned to the symbol if no value was provided from external source(s). Allowed values are: "bool", "float", "int", "hex", "text", "string". If not specified, the value type will be inferred. In case the type of values might be ambiguous, consider specifying the desired datatype for processing. In case the conversion of value to the type fails, the symbol will be skipped from further processing. For more information about supported data types and their restrictions, refer to [data type description](Reference-for-template.json.md#parameter-symbol) for parameter symbols. |no|
+
+##### Example
+
+```json
+"symbols": {
+ "HostIdentifier": {
+ "type": "bind",
+ "binding": "host:HostIdentifier"
+ },
+ "WorkingDirectory": {
+ "type": "bind",
+ "binding": "host:WorkingDirectory"
+ }
+}
+```
+
+### Binding to MSBuild properties
+
+It is possible to bind symbols to MSBuild properties of the current project. The prefix to be used: `msbuild` and it is mandatory.
+Commonly used with item templates to get the information about the project it is added to.
+
+`dotnet new` attempts to find the closest project file using following rules:
+- The project in current directory or `--output` directory (matching `*.*proj` extension).
+- If not found, the parent of above and so on.
+- The path to the project can be explicitly specified using `--project` instantiation option. This path takes precedence - so it can be used in case of ambiguity.
+
+Once project is located, its MSBuild properties are evaluated. The project should be restored, otherwise evaluation fails.
+Only .NET [SDK-style projects](https://docs.microsoft.com/en-us/dotnet/core/project-sdk/overview) are supported.
+
+It is recommended to configure `defaultValue` for `bind` symbol that will be used in case evaluation fails.
+If applicable, it is also recommended to use [project capability constraint](https://github.com/dotnet/templating/wiki/Constraints#Project-capabilities) to define the projects that the template can be added to.
+
+Example - binds `DefaultNamespace` symbol to `RootNamespace` of the project:
+```json
+"symbols": {
+ "DefaultNamespace": {
+ "type": "bind",
+ "binding": "msbuild:RootNamespace",
+ "replaces": "%NAMESPACE%",
+ "defaultValue": "TestNamespace"
+ }
+},
+"constraints": {
+ "csharp-only": {
+ "type": "project-capability",
+ "args": "CSharp + TestContainer" // only allowed in C# test project
+ }
+}
+```
+
+
+## Visual Studio specifics
+
+Visual Studio supports binding to host parameters, environment variables and MSBuild properties.
+In addition to that, there is additional `context` source supporting:
+- `context:createsolutiondirectory` - indicates whether a solution directory is to be created as a result of project creation (Place solution and project in same directory is UNCHECKED in NPD).
+- `context:isexclusive` - indicates whether the template instantiation is a result of a new project being created (true) vs result of adding to an existing solution (false).
+- `context:solutionname` - the name of the solution, which may be different from the project name.
+
+Visual Studio also provides a way to bind to "namespace" via host parameters source:
+```json
+ "type": "bind"
+ "binding": "namespace"
+```
+
+or
+
+```json
+ "type": "bind"
+ "binding": "host:namespace"
+```
diff --git a/documentation/TemplateEngine/Blog-posts.md b/documentation/TemplateEngine/Blog-posts.md
new file mode 100644
index 000000000000..1815ab277d38
--- /dev/null
+++ b/documentation/TemplateEngine/Blog-posts.md
@@ -0,0 +1,8 @@
+ - [**How to create your own templates for `dotnet new`**](https://aka.ms/dotnetnew-create-templates) by @sayedihashimi
+ - [Announcing .NET Core (includes how to use `dotnet new`)](https://blogs.msdn.microsoft.com/dotnet/2017/03/07/announcing-net-core-tools-1-0/) by @sayedihashimi
+ - [Trying out "dotnet new" template updates and csproj with VS2017](https://www.hanselman.com/blog/TryingOutDotnetNewTemplateUpdatesAndCsprojWithVS2017.aspx) by @shanselman
+ - [Custom Project Templates Using dotnet new](http://rehansaeed.com/custom-project-templates-using-dotnet-new/) by @RehanSaeed
+ - [dotnet new Feature Selection](http://rehansaeed.com/dotnet-new-feature-selection/) by @RehanSaeed
+ - [Building a Solution with dotnet cli nuget templates](https://motowilliams.com/2017-02-21-building-a-solution-with-dotnet-cli-nuget-templates/) by @motowilliams
+- [Building And Debugging The dotnet new Templating Engine In Visual Studio](http://pioneercode.com/post/building-and-debugging-the-dot-net-new-templating-engine-in-visual-studio) by @chad-ramos
+- [How To Create A dotnet new Project Template In .NET Core](http://pioneercode.com/post/how-to-create-a-dot-net-new-project-template-in-dot-net-core) - @chad-ramos
\ No newline at end of file
diff --git a/documentation/TemplateEngine/Conditional-processing-and-comment-syntax.md b/documentation/TemplateEngine/Conditional-processing-and-comment-syntax.md
new file mode 100644
index 000000000000..7d5bdab847af
--- /dev/null
+++ b/documentation/TemplateEngine/Conditional-processing-and-comment-syntax.md
@@ -0,0 +1,716 @@
+# Table of contents
+
+- [Introduction](#introduction)
+- [Known Issues](#known-issues)
+- [Language Source Files](#language-source-files)
+ - [Samples](#samples)
+ - [Ignore conditions expressions in language files](#ignore-conditions-expressions-in-language-files)
+ - [Related](#related)
+- [JSON Files](#json-files)
+ - [Samples](#samples)
+ - [Related](#related)
+- [XML Files](#xml-files)
+ - [Samples](#samples)
+ - [Related](#related)
+- [MSBuild Files](#msbuild-files)
+ - [Samples](#samples)
+ - [Ignore conditions expressions in MSBuild files](#ignore-conditions-expressions-in-msbuild-files)
+ - [Related](#related)
+- [Single hash line comments](#single-hash-line-comments)
+ - [Samples](#samples)
+ - [Related](#related)
+- [CSS Files](#css-files)
+ - [Samples](#samples)
+ - [Related](#related)
+- [Command Files](#command-files)
+ - [Samples](#samples)
+ - [Related](#related)
+- [Razor Views](#razor-views)
+ - [Samples](#samples)
+ - [Related](#related)
+- [Haml Files](#haml-files)
+ - [Samples](#samples)
+ - [Related](#related)
+- [Jsx Files](#jsx-files)
+ - [Samples](#samples)
+ - [Related](#related)
+- [Other File Types](#other-file-types)
+ - [Samples](#samples)
+ - [Related](#related)
+
+
+## Introduction
+
+To add conditional, or dynamic, content you can add Template Engine expressions in your source files. The conditional expression lets you include or exclude part of the file according to a specified condition, and to do this you can use the familiar conditional expressions like **#if**, **#else**, **#elseif**, **#endif**.
+
+To learn more about conditional expressions evaluation go to [Conditions](Conditions.md) description.
+
+
+| Name | Description |
+|----------|---------------|
+|[Language files](#language-source-files)| Common Dotnet language source files.|
+|[JSON files](#json-files) | Common Json type files. |
+|[XML files](#xml-files) | Common Xml and *tml type files. |
+|[MSBuild files](#msbuild-files)| MSBuild project files.|
+|[Single hash line comments](#single-hash-line-comments)| Common file types that use single hash line comment syntax.|
+|[Css files](#css-files)| Css Files.|
+|[Command files](#command-files)| Windows command Files.|
+|[Razor Views](#razor-views)| Razor View files.|
+|[Haml Files](#haml-files)| Haml files.|
+|[JSX Files](#jsx-files)| Jsx and Tsx files.|
+|[Other File](#other-file-types)| Default rules for file type not in this list.|
+
+## Known Issues
+
+| Name | Description | Incorrect Use | Correct Use |
+|----------|---------------|-----------------|----------------|
+|[Conditional statement overlaps with Replacement functionality](https://github.com/dotnet/templating/issues/6536)| There is a problem with using different types of conditional comments in replacement statements. In order to workaround it avoid using comments (e.g. "//") as a part of the candidate string for replacing.| "http://localhost:"| "localhost:"|
+
+#### File Extensions
+`.cs`, `.fs`,`.cpp`, `.h`, `.hpp`, `.cake`.
+
+In these file types you can use a preprocessor directive.
+
+### Samples
+
+In this sample, according to the value of the `IndividualB2CAuth` and `OrganizationalAuth` the appropriate service is added.
+
+```
+#if (IndividualB2CAuth)
+ services.AddAzureAdB2CBearerAuthentication();
+#elseif (OrganizationalAuth)
+ services.AddAzureAdBearerAuthentication();
+#endif
+
+```
+
+#### C# Sample
+
+In this sample, using the parameter symbol `addMethod` we include the definition of a new method, and its use inside the main function.
+
+```csharp
+namespace MyProject.Con
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ Console.WriteLine("Hello World!");
+#if( addMethod )
+ HelloWordAgain();
+#endif
+ }
+
+#if( addMethod )
+ static void HelloWordAgain() {
+ Console.WriteLine("Hello World Again!");
+ }
+#endif
+ }
+}
+```
+
+#### C++ Sample
+
+In this sample, using the parameter symbol `addMethod` we include the definition of a new class, and its use inside the main function.
+
+```cpp
+#include "stdafx.h"
+#include
+#include
+
+using namespace std;
+#if( addMethod )
+
+class HelloClass
+{
+public:
+ HelloClass() {
+ }
+ ~HelloClass()
+ {
+ }
+
+ void HelloWordAgain() {
+ cout << "Hello World Again!";
+ }
+};
+#endif
+
+int main()
+{
+ cout << "Hello World!";
+
+#if( addMethod )
+ HelloClass *hello = new HelloClass();
+ hello->HelloWordAgain();
+#endif
+
+ return 0;
+}
+```
+
+#### F# Sample
+
+In this sample, using the parameter symbol `addMethod` we include the definition of a new method, and its use inside the main function.
+
+```fsharp
+open System
+
+#if( addMethod )
+
+let helloWorldAgain =
+ printfn "HelloAgain"
+#endif
+
+[]
+let main argv =
+ printfn "Hello World from F#!"
+#if( addMethod )
+ helloWorldAgain
+#endif
+ 0 // return an integer exit code
+
+```
+
+#### File Extensions
+
+`.vb`.
+
+For Visual Basic file the expressions must be preceded by a `'` comment and conditional expressions are **#If**, **#ElseIf**, **#Else**, **#End If**.
+
+#### Visual Basic Sample
+
+In this sample, using the parameter symbol `addMethod` we include the definition of a new method, and its use inside the main function.
+
+```vb
+Module Module1
+
+ Sub Main()
+ Console.WriteLine("Hello World!")
+'#If( addMethod )
+ HelloWorldAgain()
+'#End If
+ End Sub
+
+'#If( addMethod )
+ Sub HelloWorldAgain()
+ Console.WriteLine("Hello World Again!")
+ End Sub
+'#End If
+End Module
+```
+
+#### File Extensions
+
+`.js`,`.ts`.
+
+With these file types the expressions must be preceded by a `//` comment .
+
+#### JavaScript Sample
+
+In this sample, using the parameter symbol `addMethod` we include the definition of a new method, and its use inside the main function.
+
+```javascript
+(function () {
+
+//#if( addMethod )
+ function helloWorldAgain() {
+ console.log("Hello World Again!");
+ }
+//#endif
+
+ console.log("Hello World!");
+//#if( addMethod )
+ helloWorldAgain();
+//#endif
+
+})();
+```
+
+#### TypeScript Sample
+
+In this sample, using the parameter symbol `addMethod` we include the definition of a new method, and its use inside the constructor.
+
+```typescript
+class Student {
+
+ constructor() {
+ console.log("Hello World!");
+//#if( addMethod )
+ this.helloWorldAgain();
+//#endif
+ }
+
+//#if( addMethod )
+ public helloWorldAgain(): void {
+ console.log("Hello World Again!");
+ }
+//#endif
+}
+```
+
+### Ignore conditions expressions in language files
+Template engine attempts to process all conditional statements in language files. In case conditions should not be processed by template engine, this should be explicitly specified.
+
+There are two ways to do it:
+- disable processing for the whole file
+- disable processing for the part of the file
+
+If the file should never be processed by template engine, it can be specified as `copyOnly` in the `sources` section of the `template.json`. For example:
+
+```json
+"sources": [
+ {
+ "modifiers": [
+ {
+ "copyOnly": [ "Directory.Build.props" ]
+ }
+ ]
+ }
+],
+```
+
+If template engine should not process only part of the file, but other parts should be processed, the conditional processing can be turned off for the section that should not be processed by using directives:
+
+`//-:cnd:noEmit`
+
+`//+:cnd:noEmit`
+
+The part `//` is the prefix to use for turning operations on and off in language files. The name `cnd` is the name of the operation to turn on/off. The `-` and `+` near the beginning of these lines indicate that the operation should be turned off, and on, respectively. The `noEmit` part tells templating to not process this line.
+
+For example:
+
+```
+#if DEBUG
+Comet.Reload.Init();
+#endif
+//-:cnd:noEmit
+#if DEBUG
+Xamarin.Calabash.Start();
+#endif
+//+:cnd:noEmit
+```
+When invoking the template with the above content, the output looks like this:
+```
+#if DEBUG
+Xamarin.Calabash.Start();
+#endif
+```
+The first expression is not emitted because it is processed, and the condition evaluated to `false`. The second expression is copied as-is because the conditional processing is turned off for that part of the file.
+
+### Related
+[C# Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.cs)
+[C++ Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.cpp)
+[F# Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.fs)
+[VB Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.vb)
+[JavaScript Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.js)
+[TypeScript Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.ts)
+
+## JSON Files
+
+For .json files, the comment block starts with `//` or `////` to the end of the line. After this marker you can add the conditional expressions.
+The choice between `//` or `////` is very important because it lets you choose between different actions to be executed when the condition is met: in the first case the content in the expression is simply rendered into the output files as is, while in the second a different action can be executed, by default uncommenting removing an eventual leading `//`.
+
+#### File Extensions
+
+`.json`, `.jsonld`, `.hjson`, `.json5`, `.geojson`, `.topojson`, `.bowerrc`, `.npmrc`, `.job`, `.postcssrc`, `.babelrc`, `.csslintrc`, `.eslintrc`, `.jade-lintrc`, `.pug-lintrc`, `.jshintrc`, `.stylelintrc`, `.yarnrc`.
+
+### Samples
+
+In this sample, we see the difference between the two ways to define conditional expression.
+If the initial `#if` condition is preceded by `//` so, if `param1 == true`, rows below are copied as is.
+second condition `#elseif`, is preceded by `////`, so if `param1 == false` and `param2 == true`, rows below will be copied after the leading `//` has been removed, resulting in
+
+```jsonc
+// comment related to the 'elseif' content
+content for when param2 is true and param1 is false
+```
+
+the latest condition, `#else`, is preceded by `////`, so the comments will removed, resulting in
+
+```jsonc
+// comment related to the 'else' content
+content for when both param1 & param2 are false
+```
+Changing from `////#else` to `//#else` the result will be
+
+```jsonc
+//// comment related to the 'else' content
+// content for when both param1 & param2 are false
+```
+
+```jsonc
+//#if (param1)
+ // comment related to the 'if' content
+ default content // also appropriate if param1 is true
+////#elseif (param2)
+ //// comment related to the 'elseif' content
+ //content for when param2 is true and param1 is false
+////#else
+ //// comment related to the 'else' content
+ // content for when both param1 & param2 are false
+//#endif
+```
+
+### Related
+[Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.json)
+
+## XML Files
+
+#### File Extensions
+
+`.*htm`, `.*html`, `.jsp`, `.asp`, `.aspx`, `.nuspec`, `.xslt`, `.xsd`, `.vsixmanifest`, `.vsct`, `.storyboard`, `.axml`, `.plist`, `.xib`, `.strings`, `.xml`, `.xaml`, `.axaml`, `.md`, `.appxmanifest`.
+
+#### Well known XML file names
+
+`app.config`, `web.config`, `web.\*.config`, `packages.config`, `nuget.config`.
+
+the comment block starts with ``. Inside this block you can add your conditional expressions.
+
+### Samples
+
+In this sample, conditional expression is inside the comment `` in the same line. According to the value of the `IndividualLocalAuth` and `UseLocalDB` symbol, an element is added.
+
+```xml
+
+ true
+
+```
+
+In this sample, conditional expression is inside the comment `` in a block.
+
+```xml
+
+```
+
+### Related
+[Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.xml)
+
+## MSBuild Files
+
+#### File Extensions
+
+`.*proj`, `.proj.user`, `.msbuild`, `.targets`, `.props`
+
+MSBuild files, in addition to the `#if`, `#else`, `#elseif`, `#endif` inside an xml type comment, a **Condition** expression could be added to an element.
+
+### Samples
+
+In this sample, one **** element will be added according to the value of the **TargetFrameworkOverride** symbol. This syntax is more clear and lets you use a single conditional expression to rule the inclusion of a whole block of content inside the template
+
+```xml
+netcoreapp2.0
+TargetFrameworkOverride
+```
+
+In this sample, we can see that if the **TargetFrameworkOverride** symbol is defined all the package references are added to the project file.
+
+```xml
+
+
+
+
+
+```
+
+In this snippet of MSBuild file, we see usage of conditional expression embedded inside a xml comment.
+
+```xml
+
+
+
+
+
+```
+
+### Ignore conditions expressions in MSBuild files
+
+ Template engine attempts to process all conditional statements in MSBuild files. In case conditions should not be processed by template engine, this should be explicitly specified.
+
+There are two ways to do it:
+- disable processing for the whole file
+- disable processing for the part of the file
+
+If the file should never be processed by template engine, it can be specified as `copyOnly` in the `sources` section of the `template.json`. For example:
+
+```json
+ "sources": [
+ {
+ "modifiers": [
+ {
+ "copyOnly": [ "Directory.Build.props" ]
+ }
+ ]
+ }
+ ],
+```
+
+If template engine should not process only part of the file, but other parts should be processed, the conditional processing can be turned off for the section that should not be processed by using directives:
+
+``
+
+``
+
+The part `
+ Bar
+
+
+
+
+ Bar
+
+
+```
+When invoking the template with the above content in `Directory.Build.props`, the output looks like this:
+```
+
+
+ Bar
+
+
+
+
+
+```
+The first ` AzureAdB2COptions
+#endif *@
+```
+
+### Related
+
+[Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.cshtml)
+
+## Haml Files
+
+#### File Extensions
+`.haml`
+
+The comment block starts with `-#` to the end of the line. After this marker you can add the conditional expressions.
+
+### Samples
+
+In this sample, according to the value of the `addParagraph` symbol, a paragraph is added.
+
+```haml
+-##if addParagraph
+ %p A new paragraph is added.
+-##endif
+```
+
+### Related
+[Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.haml)
+
+## Jsx Files
+
+#### File Extensions
+
+`.jsx `,`.tsx`
+
+The comment block starts with `{/*` and ends with `*/}`. Inside this block you can add your conditional expressions.
+
+### Samples
+
+In this sample, according to the value of the `addParagraph` symbol, a paragraph is added.
+
+```jsx
+const myElement = (
+
+ {/*#if addParagraph
+
A new paragraph is added
+ #endif*/}
+
I am a paragraph.
+
+ );
+```
+
+### Related
+[Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.jsx)
+
+## Other File Types
+
+The file types that do not have special configuration predefined in template engine or `template.json` configuration will follow default settings.
+The comment block starts with `//` to the end of the line. After this marker you can add the conditional expressions using `#if`, `#elseif`, `#endif`, `#else` directives.
+
+### Samples
+
+In this sample, according to the value of the boolean `param1` symbol, `option1` is added to the file.
+```jsx
+//#if (param1)
+option1
+//#endif
+option2
+```
+
+### Related
+[Sample](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateConditionalProcessing/Test.othertype)
diff --git a/documentation/TemplateEngine/Conditions.md b/documentation/TemplateEngine/Conditions.md
new file mode 100644
index 000000000000..5e919652d824
--- /dev/null
+++ b/documentation/TemplateEngine/Conditions.md
@@ -0,0 +1,256 @@
+# Conditions
+
+## Table of contents
+
+* [Overview](#overview)
+ * [Generated Conditions](#generated-conditions)
+ * [Example](#example)
+* [Choice symbols](#choice-symbols)
+ * [Quoteless literals](#quoteless-literals)
+ * [Multichoice symbols](#multi-choice-symbols)
+ * [Using Computed Conditions to work with Multichoice Symbols](#using-computed-conditions-to-work-with-multi-choice-symbols)
+* [Conditional parameters](#conditional-parameters)
+ * [Evaluation](#evaluation)
+ * [Performing evaluation externally](#performing-evaluation-externally)
+
+## Overview
+
+Conditions are used to drive [dynamic content generating or replacing](Conditional-processing-and-comment-syntax.md).
+
+Conditions use C++ style of [conditional preprocessor expressions](https://docs.microsoft.com/en-us/cpp/preprocessor/hash-if-hash-elif-hash-else-and-hash-endif-directives-c-cpp?view=msvc-170). Expressions are composed from constant literals (strings, numbers, `true`, `false`), [operators](https://github.com/dotnet/templating/blob/main/src/Microsoft.TemplateEngine.Core/Expressions/Cpp/Operator.cs), [symbols](https://github.com/dotnet/templating/blob/main/docs/Available-Symbols-Generators.md), brackets and whitespaces. Only single line expressions are supported. Boolean and numerical expressions are supported (nonzero value is interpreted as `true`)
+
+[Sample conditions in source code](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.Core.UnitTests/ConditionalTests.CStyleEvaluator.cs)
+
+### Generated Conditions
+Unlike C++ preprocessor conditions, template engine allows ability for using conditional expressions that are based on results of other expressions. Specifically [Evaluate](Available-Symbols-Generators.md#evaluate) and [Computed](Reference-for-template.json.md#computed-symbol) symbols can be leveraged for this purpose.
+
+### Example
+(other related sample in [GeneratorTest.json](https://github.com/dotnet/templating/blob/main/test/Microsoft.TemplateEngine.Orchestrator.RunnableProjects.UnitTests/SchemaTests/GeneratorTest.json#L82-L84)):
+
+`template.json`:
+```json
+"symbols":{
+ "langVersion": {
+ "type": "parameter",
+ "datatype": "text",
+ "description": "Sets the LangVersion property in the created project file",
+ "defaultValue": "",
+ "replaces": "$(ProjectLanguageVersion)",
+ "displayName": "Language version"
+ },
+ "csharp10orLater": {
+ "type": "generated",
+ "generator": "regexMatch",
+ "datatype": "bool",
+ "parameters": {
+ "pattern": "^(|10\\.0|10|preview|latest|default|latestMajor)$",
+ "source": "langVersion"
+ }
+ },
+ "csharpFeature_ImplicitUsings": {
+ "type": "computed",
+ "value": "csharp10orLater == \"true\""
+ },
+}
+```
+
+`Program.cs`:
+```C#
+#if (!csharpFeature_ImplicitUsings)
+using System;
+#endif
+```
+
+## Choice symbols
+
+### Quoteless literals
+
+[Choice Symbol](Reference-for-template.json.md#examples) can have one of N predefined values. Those predefined values can be referenced in the conditions as quoted literals. Unquoted literals are as well supported as opt-in feature via [`enableQuotelessLiterals`](Reference-for-template.json.md#enableQuotelessLiterals). Following 2 expressions are equivalent when opted in:
+
+`#if (PLATFORM == "Windows")`
+
+`#if (PLATFORM == Windows)`
+
+This allows for easier authoring of nested generated conditions.
+
+### Multi-choice symbols
+
+Information about multi-choice symbols can be found in [Reference for `template.json`](Reference-for-template.json.md#multichoice-symbols-specifics)
+
+Comparison to multi-choice symbol results in operation checking of a presence of any value of a multi-choice parameter - meaning `==` operator behaves as `contains()` operation. Example (sourced from [integration test](https://github.com/dotnet/templating/tree/main/test/Microsoft.TemplateEngine.TestTemplates/test_templates/TemplateWithMultiValueChoice)):
+
+`template.json`:
+```json
+ "symbols": {
+ "Platform": {
+ "type": "parameter",
+ "description": "The target platform for the project.",
+ "datatype": "choice",
+ "allowMultipleValues": true,
+ "enableQuotelessLiterals": true,
+ "choices": [
+ {
+ "choice": "Windows",
+ "description": "Windows Desktop"
+ },
+ {
+ "choice": "WindowsPhone",
+ "description": "Windows Phone"
+ },
+ {
+ "choice": "MacOS",
+ "description": "Macintosh computers"
+ },
+ {
+ "choice": "iOS",
+ "description": "iOS mobile"
+ },
+ {
+ "choice": "android",
+ "description": "android mobile"
+ },
+ {
+ "choice": "nix",
+ "description": "Linux distributions"
+ }
+ ],
+ "defaultValue": "MacOS|iOS"
+ }
+}
+```
+
+`Program.cs`:
+```C#
+#if (Platform == MacOS)
+// MacOS choice flag specified here
+#endif
+```
+
+In above example if `Platform` has it's default value (`MacOS` and `iOS`) or if those 2 values are passed to the engine (e.g. via command line: `dotnet new MyTemplate --Platform MacOS --Platform iOS`), the condition in `Program.cs` file will be evaluated as true.
+
+Order of operands doesn't matter - `PLATFORM == Windows` evaluates identical as `Windows == PLATFORM`. Comparing 2 multi-choice symbols leads to standard equality check
+
+### Using Computed Conditions to work with multi-choice symbols
+
+Cases that needs evaluation of different type of condition over multi-choice symbols than 'contains' (e.g. exclusive equality or membership in subset of possible values) can be achieved with slightly more involved condition - so we recommend definition of aliases via computed conditions.
+
+#### Example:
+
+Lets consider following multi-choice symbol:
+
+`template.json`:
+```json
+ "symbols": {
+ "PLATFORM": {
+ "type": "parameter",
+ "description": "The target platform for the project.",
+ "datatype": "choice",
+ "allowMultipleValues": true,
+ "enableQuotelessLiterals": true,
+ "choices": [
+ {
+ "choice": "Windows",
+ "description": "Windows Desktop"
+ },
+ {
+ "choice": "WindowsPhone",
+ "description": "Windows Phone"
+ },
+ {
+ "choice": "MacOS",
+ "description": "Macintosh computers"
+ },
+ {
+ "choice": "iOS",
+ "description": "iOS mobile"
+ },
+ {
+ "choice": "android",
+ "description": "android mobile"
+ },
+ {
+ "choice": "nix",
+ "description": "Linux distributions"
+ }
+ ],
+ "defaultValue": "WindowsPhone|iOS|android"
+ }
+}
+```
+
+Then Checking whether platform is a mobile platform can be performed with following condition: `(PLATFORM == android || PLATFORM == iOS || PLATFORM == WindowsPhone) && PLATFORM != Windows && PLATFORM != MacOS && PLATFORM != nix`
+
+Checking for one and only one platform needs similarly involved condition: `PLATFORM == android && PLATFORM != iOS && PLATFORM != WindowsPhone && PLATFORM != Windows && PLATFORM != MacOS`
+
+This is given by the fact that we do not support exclusive equality operator (in the future, if needed, we can introduce dedicated operator for that - e.g. `===`).
+
+To simplify templates and make them more readable - following computed conditions can be defined:
+
+`template.json`:
+```json
+ "symbols": {
+ "IsMobile": {
+ "type": "computed",
+ "value": "(PLATFORM == android || PLATFORM == iOS || PLATFORM == WindowsPhone) && PLATFORM != Windows && PLATFORM != MacOS && PLATFORM != nix"
+ },
+ "IsAndroidOnly": {
+ "type": "computed",
+ "value": "PLATFORM == android && PLATFORM != iOS && PLATFORM != WindowsPhone && PLATFORM != Windows && PLATFORM != MacOS && PLATFORM != nix"
+ },
+}
+```
+
+Usage can then look as following:
+
+`Program.cs`
+```C#
+#if IsAndroidOnly
+// This renders for android only
+#elseif IsMobile
+// This renders for rest of mobile platforms
+#else
+// This renders for desktop platforms
+#endif
+```
+
+## Conditional Parameters
+
+[Parameter symbols in template](Reference-for-template.json.md#parameter-symbol) can be specified together with optional conditions:
+* [`IsEnabled Condition`](Reference-for-template.json.md#isEnabled) - Used to determine when (or if) this symbol should be used. If this condition is specified and evaluates to `false` (or a `false` constant is passed), then this parameter is treated as if it does not exist. This applies to the use of [conditional processing of sources](Conditional-processing-and-comment-syntax.md) and [replacements](Reference-for-template.json.md#replaces). [Verification of mandatory parameters](Reference-for-template.json.md#isRequired) does not consider disabled parameters (even if marked as required).
+* [`IsRequired Condition`](Reference-for-template.json.md#isRequired) - defines if parameter is required or optional.
+
+### Evaluation
+
+**Input** - currently only other parameter symbols from the template configuration are supported within the parameter conditions. Any other variables are not bound and replaced (they are considered part of literal string).
+
+**Evaluation order** - Dependencies between parameters are detected and evaluation is performed in order that guarantees that all dependencies are evaluated prior their dependant (see [Topological Sorting](https://en.wikipedia.org/wiki/Topological_sorting) for details).
+
+ In case of cyclic dependency the evaluation proceeds only if current input values of parameters do not lead to nondeterministic result (and the cycle is indicated in warning log message). That means order of evaluation or number of reevaluations should not have impact on the result of evaluation. Otherwise an error is reported, indicating the cycle.
+
+ Example `template.json` with cyclic dependency:
+```json
+ "symbols": {
+ "A": {
+ "type": "parameter",
+ "datatype": "bool",
+ "isEnabled": "B != false",
+ "defaultValue": false
+ },
+ "B": {
+ "type": "parameter",
+ "datatype": "bool",
+ "isEnabled": "A != true",
+ "defaultValue": true
+ }
+}
+```
+
+The following input parameter values can (and will) be evaluated deterministically: `--A false --B true`
+
+The following input parameter values cannot be evaluated deterministically (and will lead to error): `--A true --B false`
+
+**Applying user, host and default values** - All user-provided, host-provided and default values are applied before the conditions are evaluated. After the evaluation default values are reapplied to parameters that were evaluated as optional and that do not have user-/host-provided values. After this an evaluation of presence of required values takes place.
+
+### Performing evaluation externally
+
+Users of Edge API can supply evaluation results of parameters conditions when instantiating template via `TemplateCreator`. More details are in [Inside the Template Engine](api/Inside-the-Template-Engine.md#supplying-parameters-conditions-results) document.
diff --git a/documentation/TemplateEngine/Constraints.md b/documentation/TemplateEngine/Constraints.md
new file mode 100644
index 000000000000..b710d99e3e3d
--- /dev/null
+++ b/documentation/TemplateEngine/Constraints.md
@@ -0,0 +1,246 @@
+# Constraints
+
+| Constraint | `type` |
+|:-----|----------|
+| [Operating system](#operating-system) | `os` |
+| [Running template engine host](#template-engine-host) | `host` |
+| [Installed workloads](#installed-workloads) | `workload` |
+| [Current SDK version](#current-sdk-version) | `sdk-version` |
+| [Project capabilities](#project-capabilities) | `project-capability` |
+
+The feature is available since .NET SDK 7.0.100.
+The template may define constraints, all of which must be met in order for the template to be usable. In case constraints are not met, the template will be installed, however will not be visible nor used by default.
+
+
+# Base configuration
+The constraints are defined under `constraints` top-level property in `template.json`. `constraints` contains objects (constraint definition). Each constraint should have a unique name, and the following properties:
+- `type`: (string) - constraint type (mandatory)
+- `args`: (string, array, object) - constraint arguments - depend on actual constraint implementation. May be optional.
+
+Example `template.json`:
+```json
+}
+ // other template elements
+
+ "constraints": {
+ "windows-only": { // Custom name - not validated
+ "type": "os", // Type of the constraint - used to match to proper Constraint component to evaluate the constraint
+ "args": "Windows" // Arguments passed to the evaluating constraint component
+ }
+ }
+}
+```
+
+## Operating system
+
+Restrict the template instantiation to certain operating system.
+
+**Configuration:**
+
+ - `type`: `os`
+ - `args`: (string, array) - list of supported operating systems. Possible values are: `Windows`, `Linux`, `OSX`.
+
+**Supported in:**
+ - all hosts (by default). 3rd party host may explicitly disable the constraint.
+
+
+### Examples
+
+```json
+"constraints": {
+ "linux-only": {
+ "type": "os",
+ "args": "Linux"
+ },
+}
+```
+```json
+"constraints": {
+ "linux-and-osx": {
+ "type": "os",
+ "args": [ "Linux", "OSX" ]
+ },
+}
+```
+
+## Template engine host
+Restrict template to be run only in certain application and its version.
+The following host identifiers are available:
+- `dotnetcli` - .NET SDK
+- `vs` - Visual Studio
+- `vs-mac` - Visual Studio for Mac
+- `ide` - may refer to both Visual Studio and Visual Studio for Mac
+- `dotnetcli-preview` - `dotnet new3` command (used for debugging testing)
+
+3rd party applications may define other host identifiers.
+
+**Configuration:**
+
+- `type`: `host`
+- `args` (array). Mandatory. Array elements can have following properties:
+ - `hostname`: (string) - the host identifier (see above)
+ - `version`: (string, optional) - supported version, or version range. If not specified, all the versions are supported.
+
+**Supported in**:
+ - all hosts (by default). 3rd party host may explicitly disable the constraint.
+
+The version and version range syntax is explained [here](https://docs.microsoft.com/en-us/nuget/concepts/package-versioning).
+
+The parsing is done in following order:
+- exact version syntax (`1.0.0`)
+- floating version syntax (`1.*`)
+- version range syntax (`(1.0,)`)
+
+### Examples
+
+Supported on .NET SDK 6.
+```json
+"constraints": {
+ "sdk-only": {
+ "type": "host",
+ "args": [
+ {
+ "hostname": "dotnetcli",
+ "version": "6.0.*"
+ }
+ ]
+ },
+}
+```
+
+Supported from .NET SDK 6.
+```json
+"constraints": {
+ "sdk-only": {
+ "type": "host",
+ "args": [
+ {
+ "hostname": "dotnetcli",
+ "version": "[6.0,)"
+ }
+ ]
+ },
+}
+```
+
+Supported in .NET SDK and Visual Studio
+```json
+"constraints": {
+ "sdk-only": {
+ "type": "host",
+ "args": [
+ {
+ "hostname": "dotnetcli"
+ },
+ {
+ "hostname": "vs"
+ },
+ ]
+ },
+}
+```
+
+## Installed Workloads
+Defines applicability of a template in the dotnet runtime with specific [workloads](https://github.com/dotnet/designs/blob/main/accepted/2020/workloads/workloads.md) installed.
+All the installed (queryable via `dotnet workload list`) as well as [extended](https://github.com/dotnet/designs/blob/main/accepted/2020/workloads/workload-manifest.md#workload-composition) workloads are inspected during evaluating of this constraint.
+
+**Configuration:**
+
+- `type`: `workload`
+- `args` (string, array). Mandatory. List of names of supported workloads (running host need to have at least one of the requested workloads installed).
+
+ To see the list of installed workloads run [`dotnet workload list`](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-workload-list). To see the list of available workloads run [`dotnet workload search`](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-workload-search)
+
+**Supported in**:
+ - .NET SDK CLI (`dotnet new`)
+ - Visual Studio 17.4
+
+### Examples
+
+```json
+"constraints": {
+ "android-runtime": {
+ "type": "workload",
+ "args": [ "microsoft-net-runtime-android", "microsoft-net-runtime-android-aot" ]
+ },
+}
+```
+```json
+"constraints": {
+ "web-assembly": {
+ "type": "workload",
+ "args": "wasm-tools"
+ },
+}
+```
+
+## Current SDK Version
+Defines .NET SDK version(s) the template can be used on.
+
+Only the currently active SDK (queryable via `dotnet --version`, changeable by the [`global.json`](https://docs.microsoft.com/en-us/dotnet/core/tools/global-json)) is being considered. Other available SDKs (queryable via `dotnet --list-sdks`) are checked for possible match and result is reported in the evaluation output with possible remedy steps - the form of reporting is dependent on the templating host.
+
+**Configuration:**
+
+- `type`: `sdk-version`
+- `args` (string, array). List of versions supported by the template. Syntax and match evaluation of versions are identical as in the [Template engine host](#template-engine-host) constraint.
+
+**Supported in**:
+ - .NET SDK CLI (`dotnet new`)
+ - Visual Studio 17.4
+
+### Examples
+
+```json
+"constraints": {
+ "LTS ": {
+ "type": "sdk-version",
+ "args": [ "6.0.*", "3.1.*" ]
+ },
+}
+```
+```json
+"current-with-previews": {
+ "web-assembly": {
+ "type": "sdk-version",
+ "args": "7.*.*-*"
+ },
+}
+```
+## Project capabilities
+Defines [project capabilities](https://github.com/microsoft/VSProjectSystem/blob/master/doc/overview/about_project_capabilities.md) that the template requires.
+Commonly used with item templates to define the certain projects it is applicable to.
+`dotnet new` attempts to find the closest project file using following rules:
+- The project in current directory or `--output` directory (matching `*.*proj` extension).
+- If not found, the parent of above and so on.
+- The path to the project can be explicitly specified using `--project` instantiation option. This path takes precedence - so it can be used in case of ambiguity.
+
+Once project is located, its project capabilities are evaluated. The project should be restored, otherwise evaluation fails.
+Only .NET [SDK-style projects](https://docs.microsoft.com/en-us/dotnet/core/project-sdk/overview) are supported.
+
+**Configuration:**
+
+- `type`: `project-capability`
+- `args`: (string) project capability [expression](https://docs.microsoft.com/en-us/dotnet/api/microsoft.visualstudio.shell.interop.vsprojectcapabilityexpressionmatcher) that should be satisfied by the project.
+
+**Supported in**:
+ - .NET SDK CLI (`dotnet new`)
+ - Visual Studio 17.4 Preview 3
+
+### Examples
+
+```json
+"constraints": {
+ "CSharp": {
+ "type": "project-capability",
+ "args": "CSharp",
+ },
+}
+```
+```json
+"constraints": {
+ "CSharpTest": {
+ "type": "project-capability",
+ "args": "CSharp & TestContainer",
+ },
+}
+```
\ No newline at end of file
diff --git a/documentation/TemplateEngine/Exit-Codes.md b/documentation/TemplateEngine/Exit-Codes.md
new file mode 100644
index 000000000000..2705494dad94
--- /dev/null
+++ b/documentation/TemplateEngine/Exit-Codes.md
@@ -0,0 +1,268 @@
+# `dotnet new` exit codes and their meaning
+
+Exit codes are chosen to conform to existing standards or standardization attempts and well known exit code. See [Related resources](#related) for more details
+
+| Exit Code | Reason |
+|:-----|----------|
+| 0 | Success |
+| [70](#70) | Unexpected internal software issue. |
+| [73](#73) | Can't create output file. |
+| [100](#100) | Instantiation Failed - Processing issues. |
+| [101](#101) | Invalid template or template package. |
+| [102](#102) | Missing required option(s) and/or argument(s) for the command. |
+| [103](#103) | The template or the template package was not found. |
+| [104](#104) | PostAction operation was cancelled. |
+| [105](#105) | Instantiation Failed - Post action failed. |
+| [106](#106) | Template/Package management operation Failed. |
+| [107 - 113](#107) | Reserved. |
+| [127](#127) | Unrecognized option(s) and/or argument(s) for a command. |
+| [130](#130) | Command terminated by user. |
+
+
+To enable verbose logging in order to troubleshoot issue(s), set the `DOTNET_CLI_CONTEXT_VERBOSE` environment variable to `true`
+
+_PowerShell:_
+```PowerShell
+$env:DOTNET_CLI_CONTEXT_VERBOSE = 'true'
+```
+
+_Cmd:_
+```cmd
+set DOTNET_CLI_CONTEXT_VERBOSE=true
+```
+
+## 70 - Unexpected internal software issue
+
+Unexpected result or issue. [File a bug](https://github.com/dotnet/templating/issues/new?title=Unexpected%20Internal%20Software%20Issue%20(EX_SOFTWARE)) if you encounter this exit code.
+
+This is a semi-standardized exit code (see [EX_SOFTWARE in /usr/include/sysexits.h](https://github.com/openbsd/src/blob/master/include/sysexits.h#L107))
+
+
+## 73 - Can't create output file.
+
+The operation was cancelled due to detection of an attempt to perform destructive changes to existing files. This can happen if you are attempting to instantiate template into the same folder where it was previously instantiated under same target name (specified via `--name` option or defaults to the target directory name)
+
+_Example:_
+```console
+> dotnet new console
+
+The template "Console App" was created successfully.
+
+Processing post-creation actions...
+Running 'dotnet restore' on C:\tmp\tmp.csproj...
+ Determining projects to restore...
+ Restored C:\tmp\tmp.csproj (in 47 ms).
+Restore succeeded.
+
+> dotnet new console
+
+Creating this template will make changes to existing files:
+ Overwrite ./tmp.csproj
+ Overwrite ./Program.cs
+
+Rerun the command and pass --force to accept and create.
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#73
+```
+
+Destructive changes can be forced by passing `--force` option.
+
+This is a semi-standardized exit code (see [EX_CANTCREAT in /usr/include/sysexits.h](https://github.com/openbsd/src/blob/master/include/sysexits.h#L110))
+
+
+## 100 - Instantiation Failed - Processing issues
+
+The template instantiation failed due to error(s). Caused by environment (failure to read/write template(s) or cache).
+
+## 101 - Invalid template or template package
+
+_Reserved for future usage - described behavior is yet not implemented. [Feature is tracked](https://github.com/dotnet/templating/issues/4801)_
+
+Caused by erroneous template(s) (incomplete conditions, symbols or macros etc.). Exact error reason will be output to stderr.
+
+_Examples:_
+
+Missing mandatory properties in template.json
+```json
+{
+ "author": "John Doe",
+ "name": "name",
+}
+```
+
+
+## 102 - Missing required option(s) and/or argument(s) for the command
+
+_Reserved for future usage - described behavior is only partially implemented. Some cases that should fall under this exit code are now leading to code [127](#127) [Issue is tracked](https://github.com/dotnet/templating/issues/4806)_
+
+The exit code is used when one or more required options or/and arguments used for the command were not passed. Applicable to `search` command with not enough information as well.
+
+Applicable as well if template option [marked as required](Reference-for-template.json.md#isrequired) was not passed during the template instantiation.
+
+_Examples:_
+```console
+> dotnet new my-template
+Mandatory option '--MyMandatoryParam' is missing for the template 'My Template'.
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#102
+```
+
+```console
+> dotnet new search
+Search failed: not enough information specified for search.
+To search for templates, specify partial template name or use one of the supported filters: '--author', '--baseline', '--language', '--type', '--tag', '--package'.
+Examples:
+ dotnet new search web
+ dotnet new search --author Microsoft
+ dotnet new search web --language C#
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#102
+```
+
+
+## 103 - The template or the template package was not found
+
+Applicable to instantiation, listing, remote sources searching and installation.
+
+_Examples:_
+```console
+> dotnet new xyz
+No templates found matching: 'xyz'.
+
+To list installed templates, run:
+ dotnet new list
+To search for the templates on NuGet.org, run:
+ dotnet new search xyz
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#103
+```
+
+```console
+> dotnet new list xyz
+No templates found matching: 'xyz'.
+
+To search for the templates on NuGet.org, run:
+ dotnet new search xyz
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#103
+```
+
+```console
+> dotnet new search xyz
+Searching for the templates...
+Matches from template source: NuGet.org
+No templates found matching: 'xyz'.
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#103
+```
+
+```console
+> dotnet new install foobarbaz
+The following template packages will be installed:
+ foobarbaz
+
+foobarbaz could not be installed, no NuGet feeds are configured or they are invalid.
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#103
+```
+
+## 104 - Post action operation was cancelled
+
+Applicable to a case when user aborts run-script post action.
+
+
+## 105 - Instantiation Failed - Post action failed
+
+Applicable to a case when post action fails - unless it is configured to [continue on errors](Post-Action-Registry.md#continueOnError).
+
+## 106 - Template/Package management operation failed
+
+The exit code is used for errors during templates installation, uninstallation or updates.
+Failure to download packages, read/write templates or cache, erroneous or corrupted template, or an attempt to install same package multiple times.
+
+_Example:_
+```console
+>dotnet nuget disable source nuget.org
+Package source with Name: nuget.org disabled successfully.
+
+> dotnet new install webapi2
+The following template packages will be installed:
+ webapi2
+
+Error: No NuGet sources are defined or enabled.
+webapi2 could not be installed, the package does not exist.
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#106
+```
+
+## 107 - 113
+
+Reserved for future use.
+
+[File a bug](https://github.com/dotnet/templating/issues/new?title=Unexpected%20Exit%20Code) if you encounter any of these exit codes.
+
+
+## 127 - Unrecognized option(s) and/or argument(s) for a command
+
+The exit code is used when one or more options or/and arguments used in the command not recognized or invalid.
+
+Usually a mismatch in type of the specified template option or unrecognized choice value.
+
+_Examples:_
+
+```console
+> dotnet new console --framework xyz
+Error: Invalid option(s):
+--framework xyz
+ 'xyz' is not a valid value for --framework. The possible values are:
+ net6.0 - Target net6.0
+ net7.0 - Target net7.0
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#127
+```
+
+```console
+dotnet new update --smth
+Unrecognized command or argument '--smth'
+
+
+
+Description:
+Checks the currently installed template packages for update, and install the updates.
+
+
+
+Usage:
+dotnet new update [options]
+
+
+
+Options:
+--interactive Allows the command to stop and wait for user input or action (for
+example to complete authentication).
+--add-source, --nuget-source Specifies a NuGet source to use during install.
+--check-only, --dry-run Only check for updates and display the template packages to be updated
+without applying update.
+-?, -h, --help Show command line help.
+
+For details on current exit code please visit https://aka.ms/templating-exit-codes#127
+```
+
+This is a semi-standardized exit code (see [127 - "command not found" in 'The Linux Documentation Project'](https://tldp.org/LDP/abs/html/exitcodes.html))
+
+
+## 130 - Command terminated by user.
+
+_Reserved for future usage - described behavior is yet not implemented. [Feature is tracked](https://github.com/dotnet/templating/issues/4799)_
+
+The exit code is used if command is terminated after user non-forceful termination request (e.g. `Ctrl-C`, `Ctrl-Break`).
+
+This is a semi-standardized exit code (see [130 - Script terminated by Control-C in 'The Linux Documentation Project'](https://tldp.org/LDP/abs/html/exitcodes.html))
+
+
+
+
+
+### Related Resources
+* [`BSD sysexit.h`](https://github.com/openbsd/src/blob/master/include/sysexits.h)
+* [`Special exit codes - The Linux Documentation Project`](https://tldp.org/LDP/abs/html/exitcodes.html)
diff --git a/documentation/TemplateEngine/Home.md b/documentation/TemplateEngine/Home.md
new file mode 100644
index 000000000000..cbd3ffe0d379
--- /dev/null
+++ b/documentation/TemplateEngine/Home.md
@@ -0,0 +1,20 @@
+# Environments using Template Engine
+- `dotnet new`
+- Visual Studio
+- Visual Studio for Mac
+
+# Community templates
+- See [available templates for dotnet new](https://github.com/dotnet/templating/wiki/Available-templates-for-dotnet-new)
+
+# Template authoring
+- [How to create templates](https://docs.microsoft.com/dotnet/core/tools/custom-templates)
+- [Samples repository](https://github.com/dotnet/dotnet-template-samples)
+- [Reference for `template.json`](Reference-for-template.json.md)
+- [Post actions](Post-Action-Registry.md)
+- [Symbols Generators](Available-Symbols-Generators.md)
+- [Value Forms](Value-Forms.md)
+- [Conditional content generation](Conditional-processing-and-comment-syntax.md)
+- [Template constraints](Constraints.md)
+- [Binding and project context evaluation](Binding-and-project-context-evaluation.md)
+- [Authoring tools: localization](authoring-tools/Localization.md)
+- [Authoring tools: testing the templates](authoring-tools/Templates-Testing-Tooling.md)
\ No newline at end of file
diff --git a/documentation/TemplateEngine/Naming-and-default-value-forms.md b/documentation/TemplateEngine/Naming-and-default-value-forms.md
new file mode 100644
index 000000000000..a9e9b4605054
--- /dev/null
+++ b/documentation/TemplateEngine/Naming-and-default-value-forms.md
@@ -0,0 +1,85 @@
+# `sourceName` default value forms
+
+`sourceName` defines the name in the source tree to replace with the name the user specifies. The value to be replaced with can be given using the `-n` `--name` options while running a template or Name field in IDE. The template engine will look for any occurrence of the name present in the config file and replace it in file names and file contents. If no name is specified by the host, the current directory is used. The value of the `sourceName` is available in built-in `name` symbol and can be used as the source for creating other symbols and condition expressions. Therefore, it is not allowed to define `name` symbol in `symbols` in template.json configuration.
+
+When selecting a `sourceName` for a template you're authoring, keep in mind the default value forms applied to this symbol:
+- `identity` - the value as entered by user.
+- `namespace` - the value transformed in a way to be a correct .NET namespace. [Details](https://github.com/dotnet/templating/blob/b0b1283f8c96be35f1b65d4b0c1ec0534d86fc2f/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/ValueForms/DefaultSafeNamespaceValueFormFactory.cs#L17-L59)
+- `class name` - the value transformed in a way to be a correct .NET class name. [Details](https://github.com/dotnet/templating/blob/b0b1283f8c96be35f1b65d4b0c1ec0534d86fc2f/src/Microsoft.TemplateEngine.Orchestrator.RunnableProjects/ValueForms/DefaultSafeNameValueFormFactory.cs#L15-L21)
+- `lower case namespace` - same as `namespace`, but lower case.
+- `lower case class name` - same as `class name`, but lower case.
+
+`sourceName` is available in template configuration as `name` variable.
+
+A good choice for `sourceName` is the value that produces distinct values under the below transformations, for example `Template.1`:
+Form | Source | Transformed value
+-------|------|--------
+`identity` | `Template.1` | `Template.1`
+`namespace` | `Template.1` | `Template._1`
+`class name` | `Template.1` | `Template__1`
+`lower case namespace` | `Template.1` | `template._1`
+`lower case class name`| `Template.1` | `template__1`
+
+In this case, you can use the transformed value to force using the form, for example:
+```csharp
+namespace Template._1; //uses `namespace` form
+
+public class Template__1 //uses `class` form
+{
+ var str = "My template name is Template.1"; //uses `identity` form
+}
+```
+
+In this case, if user use `My-App` as the name, the generated content will be as follows:
+Form | Source | Transformed value
+-------|------|--------
+`identity` | ` My-App` | `My-App`
+`namespace` | ` My-App` | `My_App`
+`class name` | `My-App` | `My_App`
+`lower case namespace` | `My-App` | `my_app`
+`lower case class name`| `My-App` | `my_app`
+
+```csharp
+namespace My_App; //uses `namespace` form
+
+public class My_App //uses `class` form
+{
+ var str = "My template name is My-App"; //uses `identity` form
+}
+```
+
+An example of wrong `sourceName` is `template1`, in this case all form transformations result in `template1`.
+Referring to previous example:
+```csharp
+namespace template1; //intent to use `namespace` form
+
+public class template1 //intent to use `class` form
+{
+ var str = "My template name is template1"; //intent to use `identity` form
+}
+```
+
+In this case, if the user use `My-App` as the name, the generated content may be as follows:
+```csharp
+namespace My-App; //intent to use `namespace` form, but `identity` was used instead. It is not guaranteed which of `My-App`, `My_App`, `my_app` will be used here.
+
+public class My-App //intent to use `class` form, but `identity` was used instead
+{
+ var str = "My template name is My_App"; //intent to use `identity` form, but `namespace` was used instead
+}
+```
+As the result, this code won't compile as namespace and class are not using correct names.
+
+Besides using the forms in template content, it is possible to access certain form of `sourceName` via the following variables:
+- `identity`: `name{-VALUE-FORMS-}identity`, equivalent to `name`.
+- `namespace`: `name{-VALUE-FORMS-}safe_namespace`
+- `class name`: `name{-VALUE-FORMS-}safe_name`
+- `lower case namespace`: `name{-VALUE-FORMS-}lower_safe_namespace`
+- `lower case class name`: `name{-VALUE-FORMS-}lower_safe_name`
+
+You can use them in conditions or other expressions of template configuration. Example:
+```xml
+Company.ConsoleApplication1
+```
+
+For more details on value forms, refer to [the article](Value-Forms.md).
\ No newline at end of file
diff --git a/documentation/TemplateEngine/Post-Action-Registry.md b/documentation/TemplateEngine/Post-Action-Registry.md
new file mode 100644
index 000000000000..370739e931d6
--- /dev/null
+++ b/documentation/TemplateEngine/Post-Action-Registry.md
@@ -0,0 +1,493 @@
+# Existing Post Actions
+
+| Description | ActionID |
+|:-----|----------|
+| [Restore NuGet packages](#restore-nuget-packages) | `210D431B-A78B-4D2F-B762-4ED3E3EA9025` |
+| [Run script](#run-script) | `3A7C4B45-1F5D-4A30-959A-51B88E82B5D2` |
+| [Open a file in the editor](#open-a-file-in-the-editor) | `84C0DA21-51C8-4541-9940-6CA19AF04EE6` |
+| [Add a reference to a project file](#add-a-reference-to-a-project-file) | `B17581D1-C5C9-4489-8F0A-004BE667B814` |
+| [Add projects to a solution file](#add-projects-to-a-solution-file) | `D396686C-DE0E-4DE6-906D-291CD29FC5DE` |
+| [Change file permissions (Unix/OS X)](#change-file-permissions) | `CB9A6CF3-4F5C-4860-B9D2-03A574959774` |
+| [Display manual instructions](#display-manual-instructions) | `AC1156F7-BB77-4DB8-B28F-24EEBCCA1E5C` |
+| [Add a property to an existing JSON file](#add-a-property-to-an-existing-json-file) | `695A3659-EB40-4FF5-A6A6-C9C4E629FCB0` |
+
+# Base configuration
+Each post action has set of standard properties as well as custom properties defined by certain post action.
+The standard properties are listed below.
+ - **Configuration** :
+ - `actionId` (string): Action ID.
+ - `condition` (string) (optional): A C++ style boolean expression defining if post action should be run. This expression may use any symbols that have been defined.
+ - `description` (string) (optional): A human-readable description of the action.
+ - `configFile` (string) (optional): Additional configuration for the associated post action. The structure & content will vary based on the post action.
+ - `continueOnError` (bool) (optional): If this action fails, the value of continueOnError indicates whether to process the next action, or stop processing the post actions. Should be set to true when subsequent actions rely on the result of the current action. The default value is false.
+ - `manualInstructions` (array) (optional): An ordered list of possible instructions to display if the action cannot be performed. Each element in the list must contain a key named "text", whose value contains the instructions. Each element may also optionally provide a key named "condition" - a boolean expression. The first instruction with blank condition is considered a default. If true conditions are present, the last one of them will be considered valid, all other ignored. It is recommended not to have more than one true condition at the time.
+ - `applyFileRenamesToArgs` (array) (optional): A list of arguments names from 'args' to which the file renames configured in symbols should be applied. By default, the file renames are not applied. Available since .NET SDK 8.0.100.
+ - `applyFileRenamesToManualInstructions` (boolean) (optional): If set to true, the file renames configured in symbols should be applied to manual instructions. By default, the file renames are not applied. Available since .NET SDK 8.0.100.
+
+# Restore NuGet packages
+
+Used to restore NuGet packages after project create.
+
+ - **Action ID** : `210D431B-A78B-4D2F-B762-4ED3E3EA9025`
+ - **Specific Configuration** :
+ - `args`:
+ - `files` (string|array) (optional):
+ - `string`: A semicolon delimited list of files that should be restored. If specified, the primary outputs will be ignored for processing. If not specified, matching primary outputs are restored.
+ - `array`: An array of files that should be restored. If specified, the primary outputs will be ignored for processing. If not specified, matching primary outputs are restored.
+
+ Note: the file path specified in `files` is used as glob pattern matching relative source path that starts with `./`. If none of the patterns is matched, matching primary outputs are restored.
+
+ Given that relative source paths are:
+ - ./src/Client/Client.csproj
+ - ./src/Client/Client.Library.csproj
+ - ./src/Client/Client.Test.csproj
+
+ The following patterns can be used.
+ |Description|Glob Pattern|
+ |-|-|
+ |Exact path matching single project|`./src/Client/Client.Test.csproj`|
+ |Wildcard `*` matching multiple projects|`./src/Client/Client.*.csproj`|
+ |Globstar `**` recursively matching multiple layers of directories|`**/Client.Library.csproj;**/Client.csproj`|
+ |File name without parent path matching the project with the same name|`Client.Library.csproj`|
+
+ - **Supported in**:
+ - `dotnet new3`
+ - `dotnet new` (2.0.0 or higher)
+ - **Ignored in**:
+ - `Visual Studio` - Visual Studio restores all projects automatically, so post action will be be ignored.
+
+Note: when using `files` argument it should contain the path to the file in source template definition, and ignore all the path and filename changes that can happen when instantiating template. For more details, see [the article](Using-Primary-Outputs-for-Post-Actions.md).
+
+### Example
+
+Restores the project mentioned in primary outputs:
+
+```
+"primaryOutputs": [
+ {
+ "path": "MyTestProject.csproj"
+ }
+],
+"postActions": [{
+ "condition": "(!skipRestore)",
+ "description": "Restore NuGet packages required by this project.",
+ "manualInstructions": [{
+ "text": "Run 'dotnet restore'"
+ }],
+ "actionId": "210D431B-A78B-4D2F-B762-4ED3E3EA9025",
+ "continueOnError": true
+}]
+```
+
+Restores the files mentioned in `files` argument. The primary outputs will be ignored.
+
+```
+"primaryOutputs": [
+ {
+ "path": "Primary/Output/PrimaryOutput.csproj" // will not be restored
+ }
+],
+"postActions": [{
+ "condition": "(!skipRestore)",
+ "description": "Restore NuGet packages required by this project.",
+ "manualInstructions": [{
+ "text": "Run 'dotnet restore'"
+ }],
+ "actionId": "210D431B-A78B-4D2F-B762-4ED3E3EA9025",
+ "continueOnError": true,
+ "args": {
+ "files": ["./Client/Client.csproj", "./Server/Server.csproj"]
+ }
+}]
+```
+
+If none of files mentioned in `files` argument is matched, the primary outputs will be restored.
+
+```
+"primaryOutputs": [
+ {
+ "path": "Primary/Output/PrimaryOutput.csproj" // will be restored
+ }
+],
+"postActions": [{
+ "condition": "(!skipRestore)",
+ "description": "Restore NuGet packages required by this project.",
+ "manualInstructions": [{
+ "text": "Run 'dotnet restore'"
+ }],
+ "actionId": "210D431B-A78B-4D2F-B762-4ED3E3EA9025",
+ "continueOnError": true,
+ "args": {
+ "files": ["Client/Client.csproj"] // This will not match any project because relative source path starts with "./"
+ }
+}]
+```
+
+# Run script
+
+Used to run a script after create.
+
+ - **Action ID** : `3A7C4B45-1F5D-4A30-959A-51B88E82B5D2`
+ - **Specific Configuration** : There are three required properties that must be specified.
+ - `args`
+ - `executable` (string): The executable to launch.
+ - `args` (string): The arguments to pass to the executable.
+ - `redirectStandardOutput` (bool) (optional): Whether or not to redirect stdout for the process (prevents output from being displayed if true). The default value is true.
+ - `redirectStandardError` (bool) (optional): Defines whether or not the stderr should be redirected. If the output is redirected, it prevents it from being displayed. The default value is true. Available since .NET SDK 6.0.100.
+ - `manualInstructions` (required)
+ - **Supported in**:
+ - `dotnet new3`
+ - `dotnet new` (2.0.0 or higher)
+
+The working directory for the launched executable is set to the root of the output template content.
+
+### Example
+
+```
+"postActions": [{
+ "actionId": "3A7C4B45-1F5D-4A30-959A-51B88E82B5D2",
+ "args": {
+ "executable": "setup.cmd",
+ "args": "",
+ "redirectStandardOutput": false,
+ "redirectStandardError": false
+ },
+ "manualInstructions": [{
+ "text": "Run 'setup.cmd'"
+ }],
+ "continueOnError": false,
+ "description ": "setups the project by calling setup.cmd"
+}]
+```
+
+# Open a file in the editor
+
+Opens a file in the editor. For command line cases this post action will be ignored.
+
+ - **Action ID** : `84C0DA21-51C8-4541-9940-6CA19AF04EE6`
+ - **Specific Configuration** :
+ - `files` (string): A semicolon delimited list of indexes to the primary outputs.
+ Note: If primary outputs are conditional, multiple post actions with the same
+ conditions as the primary outputs might be necessary.
+ - **Supported in**:
+ - since `Visual Studio 2017.3 Preview 1`
+
+### Example
+
+```
+"primaryOutputs": [
+ { "path": "Company.ClassLibrary1.csproj" },
+ {
+ "condition": "(HostIdentifier != \"dotnetcli\")",
+ "path": "Class1.cs"
+ }
+],
+"postActions": [
+ {
+ "condition": "(HostIdentifier != \"dotnetcli\")",
+ "description": "Opens Class1.cs in the editor",
+ "manualInstructions": [ ],
+ "actionId": "84C0DA21-51C8-4541-9940-6CA19AF04EE6",
+ "args": {
+ "files": "1"
+ },
+ "continueOnError": true
+ }
+]
+```
+
+# Add a reference to a project file
+ - **Action ID** : `B17581D1-C5C9-4489-8F0A-004BE667B814`
+ - **Specific Configuration** :
+ - `args`
+ - `targetFiles` (string|array) (optional):
+ - `string`: A semicolon delimited list of files that should be processed. If not specified, the project file in output directory or its closest parent directory will be used.
+ - `array`: An array of files that should be processed. If not specified, the project file in output directory or its closest parent directory will be used.
+ - `referenceType` (string): Either "package" or "project".
+ - `reference` (string): The package ID or relative path of the project to add the reference to.
+ - `projectFileExtensions` (string) (optional): A semicolon delimited list of literal file extensions to use when searching for the project to add the reference to. If not specified, `*.*proj` mask is used when searching.
+ - `version` (string) (optional) (package referenceType only): The version of the package to install.
+ - **Supported in**:
+ - `dotnet new3`
+ - `dotnet new` (2.0.0 or higher)
+
+Note: when using `targetFiles` argument it should contain the path to the file in source template definition, and ignore all the path and filename changes that can happen when instantiating template. For more details, see [the article](Using-Primary-Outputs-for-Post-Actions.md).
+
+### Example
+
+Adds a reference `Microsoft.NET.Sdk.Functions` to the project file.
+
+```
+"postActions": [{
+ "Description": "Adding Reference to Microsoft.NET.Sdk.Functions NuGet package",
+ "ActionId": "B17581D1-C5C9-4489-8F0A-004BE667B814",
+ "ContinueOnError": "false",
+ "ManualInstructions": [{
+ "Text": "Manually add the reference to Microsoft.NET.Sdk.Functions to your project file"
+ }],
+ "args": {
+ "referenceType": "package",
+ "reference": "Microsoft.NET.Sdk.Functions",
+ "version": "1.0.0",
+ "projectFileExtensions": ".csproj"
+ }
+}]
+```
+
+Includes a reference to `SomeDependency` into `MyProjectFile`. The referenced project file is in the `SomeDependency` folder.
+
+```
+"postActions": [{
+ "Description": "Adding a reference to another project",
+ "ActionId": "B17581D1-C5C9-4489-8F0A-004BE667B814",
+ "ContinueOnError": "false",
+ "ManualInstructions": [{
+ "Text": "Manually add the reference to SomeDependency to MyProjectFile"
+ }],
+ "args": {
+ "targetFiles": ["MyProjectFile.csproj"]
+ "referenceType": "project",
+ "reference": "SomeDependency/SomeDependency.csproj"
+ }
+}]
+```
+
+## Adding references to existing projects
+
+It is possible to add references to existing projects in your working directory. Since the name of the existing project is likely not a constant value for all template instantiations, a symbol can be used to pass the name of the existing project.
+
+The example below demonstrates how to add the existing project ```src/AlreadyExisting/AlreadyExisting.csproj``` as a reference to the template source project ```Project1/Project1.csproj```.
+
+```
+{
+ "symbols": {
+ "existingProject": {
+ ...
+ "type": "parameter",
+ "datatype": "string",
+ "defaultValue": "ExistingProject/ExistingProject.csproj",
+ "fileRename": "ExistingProjectPath" // Must be same as targetFile
+ }
+ },
+ "postActions": [
+ {
+ "Description": "Add ProjectReference to ExistingProject/ExistingProject.csproj",
+ "applyFileRenamesToArgs": [
+ "targetFiles" // Must be specified
+ ],
+ "args": {
+ "targetFiles": [
+ "ExistingProjectPath" // Must be same as fileRename
+ ],
+ "referenceType": "project",
+ "reference": "Project1/Project1.csproj"
+ }
+ }]
+}
+```
+
+The template above:
+- Configures the ```existingProject``` parameter *symbol* with a ```fileRename``` configuration.
+- Instructs the *'add reference to a project file'* post action to apply ```fileRename``` to the ```targetFiles``` argument.
+- Uses the value passed to the ```existingProject``` *symbol* to replace the value of the matching ```targetFiles```.
+
+This template can be instantiated using:
+
+```dotnet new [templateName] --existingProject src/AlreadyExisting/AlreadyExisting.csproj```
+
+
+# Add project(s) to a solution file
+
+ - **Action ID** : `D396686C-DE0E-4DE6-906D-291CD29FC5DE`
+ - **Specific Configuration** :
+ - `args`:
+ - `projectFiles` (string|array) (optional):
+ - `string`: A semicolon delimited list of files that should be added to solution. If not specified, primary outputs will be used instead.
+ - `array`: An array of files that should be added to solution. If not specified, primary outputs will be used instead.
+ - `primaryOutputIndexes` (string) (optional): A semicolon delimited list of indexes to the primary outputs. If not specified, all primary outputs will be added. Note: If primary outputs are conditional, multiple post actions with the same conditions as the primary outputs might be necessary.
+ - `solutionFolder` (string) (optional) (supported in 5.0.200 or higher): the destination solution folder path to add the projects to.
+ - `inRoot` (boolean) (optional) (supported in 7.0.200 or higher): whether to place the projects in the root of the solution, rather than create a solution folder. Cannot be used with `solutionFolder`.
+ - **Supported in**:
+ - `dotnet new3`
+ - `dotnet new` (2.0.0 or higher)
+ - **Ignored in**:
+ - `Visual Studio` - the user indicates where to add project explicitly, so post action defined in the template will be ignored.
+
+Note: when using `projectFiles` argument it should contain the path to the file in source template definition, and ignore all the path and filename changes that can happen when instantiating template. For more details, see [the article](Using-Primary-Outputs-for-Post-Actions.md).
+
+
+### Example
+
+Adds `MyTestProject.csproj` to solution in output directory or its closest parent directory.
+
+```
+"primaryOutputs": [
+ {
+ "path": "MyTestProject.csproj"
+ }
+],
+"postActions": [{
+ "description": "Add projects to solution",
+ "manualInstructions": [ { "text": "Add generated project to solution manually." } ],
+ "args": {
+ "solutionFolder": "src"
+ },
+ "actionId": "D396686C-DE0E-4DE6-906D-291CD29FC5DE",
+ "continueOnError": true
+}]
+```
+
+Adds `MyTestProject.csproj` to solution in output directory or its closest parent directory (using `projectFiles` argument).
+
+```
+"postActions": [{
+ "description": "Add projects to solution",
+ "manualInstructions": [ { "text": "Add generated project to solution manually." } ],
+ "args": {
+ "solutionFolder": "src",
+ "projectFiles": ["MyTestProject.csproj"]
+ },
+ "actionId": "D396686C-DE0E-4DE6-906D-291CD29FC5DE",
+ "continueOnError": true
+}]
+```
+
+Adds `MyTestProject.csproj` in the root of the solution.
+
+```json
+"primaryOutputs": [{
+ "path": "MyTestProject.csproj"
+ }
+],
+"postActions": [{
+ "description": "Add projects to solution",
+ "manualInstructions": [{
+ "text": "Add generated project to solution manually."
+ }
+ ],
+ "args": {
+ "inRoot": true
+ },
+ "actionId": "D396686C-DE0E-4DE6-906D-291CD29FC5DE",
+ "continueOnError": true
+ }
+]
+```
+
+# Change file permissions
+
+Unix / OS X only (runs the Unix `chmod` command).
+
+ - **Action ID** : `CB9A6CF3-4F5C-4860-B9D2-03A574959774`
+ - **Specific Configuration** :
+ - `args`: The permissions to set (see examples). Usually this will contain a glob like `{ "+x": "*.sh" }` or a list of filenames like `{ "+x": ["script1", "script2"] }`.
+ - **Supported in**:
+ - `dotnet new3`
+ - `dotnet new` (2.0.0 or higher)
+
+### Example
+
+```
+"postActions": [{
+ "condition": "(OS != \"Windows_NT\")",
+ "description": "Make scripts executable",
+ "manualInstructions": [{
+ "text": "Run 'chmod +x *.sh'"
+ }],
+ "actionId": "cb9a6cf3-4f5c-4860-b9d2-03a574959774",
+ "args": {
+ "+x": "*.sh"
+ },
+ "continueOnError": true
+}]
+```
+
+or
+
+```
+"postActions": [{
+ "condition": "(OS != \"Windows_NT\")",
+ "description": "Make scripts executable",
+ "manualInstructions": [ { "text": "Run 'chmod +x *.sh somethingelse'" } ],
+ "actionId": "cb9a6cf3-4f5c-4860-b9d2-03a574959774",
+ "args": {
+ "+x": [
+ "*.sh",
+ "somethingelse"
+ ]
+ },
+ "continueOnError": true
+}]
+```
+
+# Display manual instructions
+
+Prints out the manual instructions after instantiating template in format:
+```
+Description:
+Manual instructions:
+Actual command:
+```
+
+Command is printed only if defined in post action arguments.
+
+ - **Action ID** : `AC1156F7-BB77-4DB8-B28F-24EEBCCA1E5C`
+ - **Specific Configuration** :
+ - `args`:
+ - `executable` (string) (optional): command to run
+ - `args` (string) (optional): arguments to use
+ - **Supported in**:
+ - `dotnet new3`
+ - `dotnet new` (2.0.0 or higher)
+
+### Example
+
+```
+"postActions": [{
+ "description": "Manual actions required",
+ "manualInstructions": [{
+ "text": "Run the following command"
+ }],
+ "actionId": "AC1156F7-BB77-4DB8-B28F-24EEBCCA1E5C",
+ "args": {
+ "executable": "setup.cmd",
+ "args": ""
+ },
+ "continueOnError": true
+}]
+```
+
+# Add a property to an existing JSON file
+
+Adds a new JSON property in an existing JSON file.
+
+- **Action ID** : 695A3659-EB40-4FF5-A6A6-C9C4E629FCB0
+- **Specific Configuration** :
+ - `args`:
+ - `jsonFileName (string)`: The path to the JSON file that must be modified.
+ - `parentPropertyPath (string)` (optional): Specifies an existing property in the JSON file for which the new property must be a child property. The complete path must be specified, using a colon (:) as a separator character, for instance, `Person:Address`. If parentPropertyPath is not defined, the new property will be added to the root of the JSON document.
+ - `newJsonPropertyName (string)`: The name that must be given to the new property.
+ - `newJsonPropertyValue (string)`: The value that must be assigned to the new property. This must be a valid JSON.
+ - Starting in .NET 10 SDK, the following are also supported:
+ - `detectRepositoryRoot (bool)`: Whether or not a detection logic to find repo root is enabled. When the JSON file is not found, it will be created in the detected repo root if this option is true. Also when searching for an existing JSON file, the search will stop at the repo root and won't consider any parent directories. The default is `false`.
+ - `includeAllDirectoriesInSearch (bool)`: Whether or not sub-directories are searched for a matching json file (i.e, use `SearchOption.AllDirectories`). The default is `true`.
+ - `includeAllParentDirectories (bool)`: Whether or not all parent directories (up to repo root, if `detectRepositoryRoot` is true) are searched for a matching JSON file. When `false`, only one level up is searched. The default is `false`.
+- **Supported in** :
+ - dotnet new3
+ - dotnet new (2.0.0 or higher)
+
+## Example
+```
+"postActions": [{ `
+ `"description": "Adds a new JSON property in an existing JSON file.",`
+ `"manualInstructions": [ { "text": "Add a new property 'LogLevel' with value 'Information' to '.\deployment.json' under existing property 'moduleConfiguration:edgeAgent:properties.desired'" } ],`
+ `"actionId": "695A3659-EB40-4FF5-A6A6-C9C4E629FCB0",`
+ `"args": {`
+ `"jsonFileName": ".\deployment.json",`
+ `"parentPropertyPath": "moduleConfiguration:edgeAgent:properties.desired",`
+ `"newJsonPropertyName": "LogLevel",`
+ `"newJsonPropertyValue": "Information"`
+ `},`
+ `"continueOnError": true`
+`}]
+```
diff --git a/documentation/TemplateEngine/Reference-for-template.json.md b/documentation/TemplateEngine/Reference-for-template.json.md
new file mode 100644
index 000000000000..9bcdba08135a
--- /dev/null
+++ b/documentation/TemplateEngine/Reference-for-template.json.md
@@ -0,0 +1,692 @@
+## Overview
+
+This page describes the available properties of `template.json` configuration file.
+
+The templates defined using `template.json`are still the "runnable projects" A "runnable project" is a project that can be
+executed as a normal project can. Instead of updating your source files to be tokenized you define replacements, and other processing, mostly in an external file,
+the `template.json` file. This requires that a few changes have to be done on the fly during the preparation of the package, and in the `template.json` we define all the operations needed to create a well working package.
+
+**Benefits of "runnable project" templates**
+* Code format is not modified, therefore existing editors work great for template content
+* You can still build, run, debug and test your template just like any other project
+* No injection of special templating tokens into the project is required (though possible)
+
+**Typical layout on disk**
+```
+ .template.config/
+ template.json
+ MyTemplate/
+ MyTemplate.csproj
+ Program.cs
+```
+
+The templates can be packaged to a NuGet package for further distribution.
+A tutorial on how to create the template package can be found [here](https://learn.microsoft.com/en-us/dotnet/core/tutorials/cli-templates-create-template-package).
+
+
+|Category|Description|
+|------|------|
+|[Template Definition](#template-definition)|Metadata of the template|
+|[Content Manipulation](#content-manipulation)|Configuration of content changes in source files|
+|[Output Management](#output-management)|Configuration of the final output|
+
+### Template Definition
+|Name|Description|Mandatory|
+|---|---|---|
+|`identity`|A unique name for this template|yes|
+|`author`|The author of the template|no|
+|`classifications`| Zero or more characteristics of the template which are shown in the tabular output of `dotnet new list` and `dotnet new search` as "Tags". It is possible to filter the templates based on them using `--tag` option. In Visual Studio those items are shown in New Project Dialog in the available list of templates together with template name, description and language. Common classifications are: `Library`, `Test`, `Web` etc. |no|
+|`name`|The name for the template. This is displayed as the template name when using `dotnet new` and Visual Studio.|yes|
+|`groupIdentity`|The ID of the group this template belongs to. This allows multiple templates to be displayed as one, with the decision for which one to use based on the template options. See more information on templates grouping in [this article](./Using-Group-Identity.md). |no|
+|`tags`|You can use tags to improve the metadata of your project. Well-known tags are: `language` and `type`. To specify the template language, use the tag `language`. To specify the template type, use the tag `type`. Supported types are: `project`, `item`, `solution`.|no|
+|`shortName`|A name for selecting the template in CLI environment. This is the name shown as `Short Name` in `dotnet new` list of templates, and is the name to use to run this template. It is possible to specify multiple short names for the single template, and then any of them can be used to instantiate the template. The first element of the array is considered as the primary and first choice in scenarios where only single value is allowed (for example in tab completion of `dotnet new`). Be mindful when selecting the short name and using synonyms to avoid conflicts with other templates - the template short name should be unique. In case multiple template with the same short name are installed at the same time, the user won't be able to use any of them until one of the packages is uninstalled making the short name unique again. This doesn't apply for the templates that are part of the same group (have same `groupIdentity`). |yes|
+|`postActions`|Enables actions to be performed after the project is created. See [the article](Post-Action-Registry.md) on post actions for more details.|no|
+|`constraints`|[Template constraints](#template-constraints)||no|
+
+#### Template constraints
+
+Available since .NET SDK 7.0.100.
+The template may define the constraints all of which must be met in order for the template to be used.
+In case constraints are not met, the template will be installed, however will not be visible by default.
+For the details on available constraints, refer to [the article](Constraints.md).
+The constraints are defined under `constraints` property (top level in template.json). `constraints` contains objects (constraint definition). Each constraint should have a unique name, `type` and optional arguments (`args`). Argument syntax depends on the constraint implementation.
+
+```json
+"constraints": {
+ "linux-only": {
+ "type": "os",
+ "args": "Linux"
+ },
+ "sdk-only": {
+ "type": "host",
+ "args": [
+ {
+ "hostname": "dotnetcli",
+ "version": "[6.0.100, )"
+ }
+ ]
+ }
+}
+```
+
+### Content Manipulation
+|Name|Description|Default|Mandatory|
+|---|---|---|---|
+|`sources`|The set of mappings in the template content to user directories. It's defined as any array of [Source](#source-definition) |If not specified, an implicit source is created with `"source": "./"` and `"target": "./"`, all other properties in the source are set to their defaults|no|
+|`guids`|[Guids](#guids)||no|
+|`symbols`|[Symbols](#symbols)||no|
+|`forms`|[Value forms](Value-Forms.md)||no|
+
+#### Source Definition
+|Name|Description|Default|Mandatory|
+|---|---|---|---|
+|`source`|The path in the template content (relative to the directory containing the .template.config folder) that should be processed|`./`|no|
+|`target`|The path (relative to the directory the user has specified) that content should be written to|`./`|no|
+|`include`|The set of globing patterns indicating the content to process in the path referred to by `source`|[ "**/*" ]|no|
+|`exclude` |The set of globing patterns indicating the content that was included by sources.include that should not be processed|`[ "**/[Bb]in/**", "**/[Oo]bj/**", ".template.config/**/*", "**/*.filelist", "**/*.user", "**/*.lock.json" ]`|no|
+|`copyOnly` |The set of globing patterns indicating the content that was included by `include`, that hasn't been excluded by sources.exclude that should be placed in the user's directory without modification|`[ "**/node_modules/**/*" ]`|no|
+|`rename`|The set of explicit renames to perform. Each key is a path to a file in the source, each value is a path to the target location - only the values will be evaluated with the information the user supplies||no|
+|`condition`|A boolean condition to indicate if the sources configuration should be included or ignored. If the condition evaluates to `true` or is not provided, the sources config will be used for creating the template. If it evaluates to `false`, the sources config will be ignored||no|
+|`modifiers`|A list of additional source information which gets added to the top-level source information, based on evaluation the corresponding `source.modifiers.condition`. Is defined as an array of [Modifier](#modifier-definition)||no|
+
+#### Modifier Definition
+|Name|Description|Mandatory|
+|---|---|---|
+|`condition`|A boolean condition to indicate if the `sources.modifiers` instance should be included or ignored. If the condition evaluates to `true` or is not provided, the `sources.modifiers` instance will be used for creating the template. If it evaluates to false, the `sources.modifiers` config will be ignored.|yes|
+|`include`|Include configuration specific to this `sources.modifiers` instance, contingent on the corresponding `sources.modifiers.condition`. See `sources.include` for more info.|no|
+|`exclude`|Exclude configuration specific to this `sources.modifiers` instance, contingent on the corresponding `sources.modifiers.condition`. See `sources.exclude` for more info|no|
+|`copyOnly`|CopyOnly configuration specific to this `sources.modifiers` instance, contingent on the corresponding `sources.modifiers.condition`. See `sources.copyOnly` for more info|no|
+
+### Guids
+An optional list of guids which appear in the template source and should be replaced in the template output. For each guid listed, a replacement guid is generated, and replaces all occurrences of the source guid in the output. Matching of the guids in the source template works independently on the format and casing of the guids in the `template.json` file and source files. Format and casing from template source is preserved in the output (casing and format of the guid in `Guids` section of `template.json` doesn't influence matching or output generation).
+
+##### Example
+Sample template.json snippet:
+```json
+ "guids": [
+ "98048C9C-BF28-46BA-A98E-63767EE5E3A8",
+ "c7ab42cf938548c08b8784349ab5e04b"
+ ],
+```
+
+Sample template file content:
+```console
+[n]: 98048c9cbf2846baa98e63767ee5e3a8
+[d]: 98048c9c-bf28-46ba-a98e-63767ee5e3a8
+[b]: {98048c9c-bf28-46ba-a98e-63767ee5e3a8}
+[p]: (98048c9c-bf28-46ba-a98e-63767ee5e3a8)
+[x]: {0x98048c9c,0xbf28,0x46ba,{0xa9,0x8e,0x63,0x76,0x7e,0xe5,0xe3,0xa8}}
+[N]: 98048C9CBF2846BAA98E63767EE5E3A8
+[D]: 98048C9C-BF28-46BA-A98E-63767EE5E3A8
+[B]: {98048C9C-BF28-46BA-A98E-63767EE5E3A8}
+[P]: (98048C9C-BF28-46BA-A98E-63767EE5E3A8)
+[X]: {0X98048C9C,0XBF28,0X46BA,{0XA9,0X8E,0X63,0X76,0X7E,0XE5,0XE3,0XA8}}
+
+[n]: c7ab42cf938548c08b8784349ab5e04b
+[d]: c7ab42cf-9385-48c0-8b87-84349ab5e04b
+[b]: {c7ab42cf-9385-48c0-8b87-84349ab5e04b}
+[p]: (c7ab42cf-9385-48c0-8b87-84349ab5e04b)
+[x]: {0xc7ab42cf,0x9385,0x48c0,{0x8b,0x87,0x84,0x34,0x9a,0xb5,0xe0,0x4b}}
+[N]: C7AB42CF938548C08B8784349AB5E04B
+[D]: C7AB42CF-9385-48C0-8B87-84349AB5E04B
+[B]: {C7AB42CF-9385-48C0-8B87-84349AB5E04B}
+[P]: (C7AB42CF-9385-48C0-8B87-84349AB5E04B)
+[X]: {0XC7AB42CF,0X9385,0X48C0,{0X8B,0X87,0X84,0X34,0X9A,0XB5,0XE0,0X4B}}
+```
+
+Output content after template instantiation:
+```console
+[n]: a6d920ff125841318f5e07df108f5a4a
+[d]: a6d920ff-1258-4131-8f5e-07df108f5a4a
+[b]: {a6d920ff-1258-4131-8f5e-07df108f5a4a}
+[p]: (a6d920ff-1258-4131-8f5e-07df108f5a4a)
+[x]: {0xa6d920ff,0x1258,0x4131,{0x8f,0x5e,0x07,0xdf,0x10,0x8f,0x5a,0x4a}}
+[N]: A6D920FF125841318F5E07DF108F5A4A
+[D]: A6D920FF-1258-4131-8F5E-07DF108F5A4A
+[B]: {A6D920FF-1258-4131-8F5E-07DF108F5A4A}
+[P]: (A6D920FF-1258-4131-8F5E-07DF108F5A4A)
+[X]: {0XA6D920FF,0X1258,0X4131,{0X8F,0X5E,0X07,0XDF,0X10,0X8F,0X5A,0X4A}}
+
+[n]: 2879773c9a5241f78fa5ac318214f54d
+[d]: 2879773c-9a52-41f7-8fa5-ac318214f54d
+[b]: {2879773c-9a52-41f7-8fa5-ac318214f54d}
+[p]: (2879773c-9a52-41f7-8fa5-ac318214f54d)
+[x]: {0x2879773c,0x9a52,0x41f7,{0x8f,0xa5,0xac,0x31,0x82,0x14,0xf5,0x4d}}
+[N]: 2879773C9A5241F78FA5AC318214F54D
+[D]: 2879773C-9A52-41F7-8FA5-AC318214F54D
+[B]: {2879773C-9A52-41F7-8FA5-AC318214F54D}
+[P]: (2879773C-9A52-41F7-8FA5-AC318214F54D)
+[X]: {0X2879773C,0X9A52,0X41F7,{0X8F,0XA5,0XAC,0X31,0X82,0X14,0XF5,0X4D}}
+```
+
+### Symbols
+The symbols section defines variables and their values, the values may be the defined in terms of other symbols. When a defined symbol name is encountered anywhere in the template definition, it is replaced by the value defined in this configuration. The symbols configuration is a collection of key-value pairs. The keys are the symbol names, and the value contains key-value-pair configuration information on how to assign the symbol a value.
+The supported symbol types are:
+- Parameter
+- Derived
+- Computed
+- Generated
+- Bind
+
+There are 3 places from which a symbol can acquire its value:
+- Template configuration (this).
+- Host provided values, which override template configuration values. For example, the host may provide the operating system kind as "Linux", overriding a template default value of "Windows".
+- User provided values, which override host & template values. The way these are provided to the template generation broker is specific to the broker. This may be via additional configuration files, command line parameters, inputs to a UI, etc.
+
+#### Parameter symbol
+
+A symbol for which the config provides literal and/or default values.
+
+|Name|Description|Mandatory|
+|---|---|---|
+|`type`|`parameter`| yes |
+|`dataType`| Supported values: - `bool`: boolean type, possible values: `true`/`false`. - `choice`: enumeration, possible values are defined in `choices` property. - `float`: double-precision floating format number. Accepts any value that can be parsed by `double.TryParse()`. - `int`/`integer`: 64-bit signed integer. Accepts any value that can be parsed by `long.TryParse()`. - `hex`: hex number. Accepts any value that can be parsed by `long.TryParse(value.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out long convertedHex)`. - `text`/`string`: string type. - ``: treated as string.| no, default - `string` |
+|`defaultValue`|The value assigned to the symbol if no parameter is provided by the user or host. The default is *not applied* if [`isRequired`](#isRequired) configuration is set to `true` for a parameter (or is set to condition that evaluates to `true`), as that is an indication that user specified value is required. | no |
+|`defaultIfOptionWithoutValue`|The value assigned to the symbol if explicit `null` parameter value is provided by the user or host.|no |
+|`replaces`|The text to be replaced by the symbol value in the template files content| no |
+|`fileRename`|The portion of template filenames to be replaced by the symbol value.| no |
+|`description`|Human readable text describing the meaning of the symbol. This has no effect on template generation.| no |
+|`isRequired`|Optional. Indicates if the user supplied value is required or not. Might be a fixed boolean value or a condition string that evaluates based on passed parameters - more details in [Conditions documentation](Conditions.md#conditional-parameters). If set to `true` (or condition that evaluates to `true`) and user has not specified the value on input, validation error occurs - even if [`defaultValue`](#defaultValue) is present.| no |
+|`isEnabled`| Optional condition indicating whether parameter should be processed. Might be a fixed boolean value or a condition string that evaluates based on passed parameters - more details in [Conditions documentation](Conditions.md#conditional-parameters).| no |
+|`choices`|Applicable only when `datatype=choice.` List of available choices. Contains array of the elements: - `choice`: possible value of the symbol. - `description`: human readable text describing the meaning of the choice. This has no effect on template generation. If not provided, there are no valid choices for the symbol, so it can never be assigned a value.| yes, for `dataType` = `choice` |
+|`allowMultipleValues`|Applicable only when `datatype=choice`. Enables ability to specify multiple values for single symbol.| no |
+|`enableQuotelessLiterals`|Applicable only when `datatype=choice`. Enables ability to specify choice literals in conditions without quotation.|no |
+|`onlyIf`| Defines the conditions that should be fulfilled in order that replacement happens. |no |
+|`forms`|Defines the set of transforms that can be referenced by symbol definitions. Forms allow the specification of a "replaces"/"replacement" pair to also apply to other ways the "replaces" value may have been specified in the source by specifying a transform from the original value of "replaces" in configuration to the one that may be found in the source. [Details](Value-Forms.md)|no |
+
+##### Examples
+Boolean optional parameter with default value `false`:
+```json
+ "symbols": {
+ "TestProject": {
+ "type": "parameter",
+ "dataType": "bool",
+ "defaultValue": "false"
+ }
+ },
+```
+
+Choice optional parameter with 3 possible values:
+```json
+ "symbols": {
+ "Framework": {
+ "type": "parameter",
+ "description": "The target framework for the project.",
+ "datatype": "choice",
+ "enableQuotelessLiterals": true,
+ "choices": [
+ {
+ "choice": "netcoreapp3.1",
+ "description": "Target netcoreapp3.1"
+ },
+ {
+ "choice": "netstandard2.1",
+ "description": "Target netstandard2.1"
+ },
+ {
+ "choice": "netstandard2.0",
+ "description": "Target netstandard2.0"
+ }
+ ],
+ "replaces": "netstandard2.0",
+ "defaultValue": "netstandard2.0"
+ }
+}
+```
+
+String optional parameter, replaces TargetFrameworkOverride:
+```json
+ "symbols": {
+ "TargetFrameworkOverride": {
+ "type": "parameter",
+ "description": "Overrides the target framework",
+ "replaces": "TargetFrameworkOverride",
+ "datatype": "string",
+ "defaultValue": ""
+ }
+}
+```
+
+#### Multi-choice symbols specifics
+Multi-choice symbols have similar behavior and usage scenarios as [C# Flag enums](https://docs.microsoft.com/en-us/dotnet/api/system.flagsattribute) - they express a range of possible values (not a single value - unlike the plain [choice symbol](#choice-sample))
+
+##### Example definition of multi-choice symbol:
+
+```json
+"symbols":
+{
+ "Platform": {
+ "type": "parameter",
+ "description": "The target platform for the project.",
+ "datatype": "choice",
+ "allowMultipleValues": true, // multi-choice indicator
+ "choices": [
+ {
+ "choice": "Windows",
+ "description": "Windows Desktop"
+ },
+ {
+ "choice": "MacOS",
+ "description": "Macintosh computers"
+ },
+ {
+ "choice": "iOS",
+ "description": "iOS mobile"
+ },
+ {
+ "choice": "android",
+ "description": "android mobile"
+ },
+ {
+ "choice": "nix",
+ "description": "Linux distributions"
+ }
+ ],
+ "defaultValue": "MacOS|iOS"
+ }
+}
+```
+
+There are some specifics in behavior of multi-choice symbols that are worth noting:
+
+* Condition evaluation - closer described in [Conditions document](Conditions.md#multichoice-literals).
+* [`Switch` symbol](Available-Symbols-Generators.md#switch) evaluation - conditions are evaluated by identical evaluator as preprocessing conditions (previous bullet point).
+* Argument passing and tab completion on CLI - User can specify multiple options via repeating the argument switch for each option:
+ `dotnet new MyTemplate --MyParameter value1 --MyParameter value2`
+
+ or by passing multiple tokens to single option switch:
+
+ `dotnet new MyTemplate --MyParameter value1 value2`
+
+ Tab completion works identically as for standard choice symbol
+
+* Default values specification and API usage - Currently multiple values can be specified within single string separated by `|` or `,` characters. Escaping of those characters within values is currently not supported.
+* Using multi-choice value as a string in template content - this can be achieved via leveraging the [`join` symbol](Available-Symbols-Generators.md#multichoice-join-sample). For simplicity it is as well possible to specify replacement for choice symbol with multiple values - in such case the values will be rendered into single string separated by `|` sign.
+
+
+
+#### Derived symbol
+
+A symbol that defines transformation of another symbol. The value of this symbol is derived from the value of another symbol by the application of form defined in `valueTransform`.
+
+|Name|Description|Mandatory|
+|---|---|---|
+|`type`|`derived`| yes |
+|`valueSource`|The name of the other symbol which value will be used to derive this value.| yes |
+|`valueTransform`|The name of the value form to apply to the source value.| yes |
+|`replaces`|The text to be replaced by the symbol value in the template files content| no |
+|`fileRename`|The portion of template filenames to be replaced by the symbol value.| no |
+|`description`|Human readable text describing the meaning of the symbol. This has no effect on template generation.| no |
+
+##### Examples
+Renames `Application1` file to value of `name` symbol after last dot
+```json
+{
+...
+ "symbols": {
+ "app1Rename": {
+ "type": "derived",
+ "valueSource": "name",
+ "valueTransform": "ValueAfterLastDot",
+ "fileRename": "Application1",
+ "description": "A value derived from the 'name' param, used to rename Application1.cs"
+ }
+ }
+...
+ "forms": {
+ "ValueAfterLastDot": {
+ "identifier": "replace",
+ "pattern": "^.*\\.(?=[^\\.]+$)", // regex to match everything up to and including the final "."
+ "replacement": "" // replace it with empty string
+ }
+ }
+...
+}
+```
+
+#### Generated symbol
+
+A symbol which value gets computed by a built-in symbol value generator. [Details](Available-Symbols-Generators.md)
+
+|Name|Description|Mandatory|
+|---|---|---|
+|`type`|`generated`| yes |
+|`generator`|Generator to use: See [this article](Available-Symbols-Generators.md) for more details.| yes |
+|`parameters`|The parameters for generator. See [description](Available-Symbols-Generators.md) for each generator for details.| depends on generator |
+|`replaces`|The text to be replaced by the symbol value in the template files content| no |
+|`fileRename`|(supported in 5.0.200 or higher) The portion of template filenames to be replaced by the symbol value.| no |
+|`dataType`| Supported values: - `bool`: boolean type, possible values: `true`/`false`. - `float`: double-precision floating format number. Accepts any value that can be parsed by `double.TryParse()`. - `int`/`integer`: 64-bit signed integer. Accepts any value that can be parsed by `long.TryParse()`. - `hex`: hex number. Accepts any value that can be parsed by `long.TryParse(value.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out long convertedHex)`. - `text`/`string`: string type. - ``: treated as string.| no, default: `string` |
+
+##### Example
+
+- `myconstant`: replaces `1234` with `5001`
+- `ownername`: replaces `John Smith (a)` with the value of the `ownername` parameter
+- `nameUpper`:
+ - replaces `John Smith (U)` with the value of the `ownername` parameter in upper case in template files content
+ - replaces `author_uc` with the value of the `ownername` parameter in upper case in filenames
+- `nameLower`:
+ - replaces `John Smith (l)` with the value of the `ownername` parameter in lower case in template files content
+ - replaces `author_lc` with the value of the `ownername` parameter in lower case in filenames
+
+```json
+"symbols":{
+ "myconstant": {
+ "type": "generated",
+ "generator": "constant",
+ "parameters": {
+ "value":"5001"
+ },
+ "replaces":"1234"
+ },
+ "ownername":{
+ "type": "parameter",
+ "datatype":"text",
+ "replaces": "John Smith (a)",
+ "defaultValue": "John Doe"
+ },
+ "nameUpper":{
+ "type": "generated",
+ "generator": "casing",
+ "parameters": {
+ "source":"ownername",
+ "toLower": false
+ },
+ "replaces":"John Smith (U)",
+ "fileRename": "author_uc"
+ },
+ "nameLower":{
+ "type": "generated",
+ "generator": "casing",
+ "parameters": {
+ "source":"ownername",
+ "toLower": true
+ },
+ "replaces":"John Smith (l)",
+ "fileRename": "author_lc"
+ }
+}
+```
+
+#### Computed symbol
+
+A symbol for which the config provides a Boolean predicate whose evaluation result is the computed symbol result.
+
+|Name|Description|Mandatory|
+|---|---|---|
+|`type`|`computed`| yes |
+|`value`| Boolean expression to be computed.| yes |
+|`evaluator`|Language to be used for evaluation of expression: - `C++2` - `C++` - `MSBUILD` - `VB`| no, default: `C++2` |
+
+Please note that math operations are not supported in expressions at this point.
+
+##### Example
+
+Values of `OrganizationalAuth`, `WindowsAuth`, `MultiOrgAuth`, `SingleOrgAuth`, `IndividualAuth`, `NoAuth`, `RequiresHttps` symbols are computed based on `auth` symbol.
+
+```json
+ "symbols": {
+ "auth": {
+ "type": "parameter",
+ "datatype": "choice",
+ "choices": [
+ {
+ "choice": "None",
+ "description": "No authentication"
+ },
+ {
+ "choice": "Individual",
+ "description": "Individual authentication"
+ },
+ {
+ "choice": "SingleOrg",
+ "description": "Organizational authentication for a single tenant"
+ },
+ {
+ "choice": "MultiOrg",
+ "description": "Organizational authentication for multiple tenants"
+ },
+ {
+ "choice": "Windows",
+ "description": "Windows authentication"
+ }
+ ],
+ "defaultValue": "Individual",
+ "description": "The type of authentication to use"
+ },
+ "OrganizationalAuth": {
+ "type": "computed",
+ "value": "(auth == \"SingleOrg\" || auth == \"MultiOrg\")"
+ },
+ "WindowsAuth": {
+ "type": "computed",
+ "value": "(auth == \"Windows\")"
+ },
+ "MultiOrgAuth": {
+ "type": "computed",
+ "value": "(auth == \"MultiOrg\")"
+ },
+ "SingleOrgAuth": {
+ "type": "computed",
+ "value": "(auth == \"SingleOrg\")"
+ },
+ "IndividualAuth": {
+ "type": "computed",
+ "value": "(auth == \"Individual\")"
+ },
+ "NoAuth": {
+ "type": "computed",
+ "value": "(!(IndividualAuth || MultiOrgAuth || SingleOrgAuth || WindowsAuth))"
+ },
+ "RequiresHttps": {
+ "type": "computed",
+ "value": "(OrganizationalAuth)"
+ }
+ }
+```
+
+#### Bind symbol
+See [the article](Binding-and-project-context-evaluation.md#bind-symbols).
+
+
+### Output Management
+|Name|Description|Default|Mandatory|
+|---|---|---|---|
+|`sourceName`| The text in the source content to replace with the name the user specifies. The value to be replaced with can be given using the `-n` `--name` options while running a template. The template engine will look for any occurrence of the `sourceName` present in the config file and replace it in file names and file contents. If no name is specified by the host, the current directory is used. The value of the `sourceName` is available in built-in `name` symbol and can be used as the source for creating other symbols and condition expressions. Due to implicit forms applied to `sourceName` it is important to select the replacement that doesn't cause the conflicts. See more details about `sourceName` in [the article](Naming-and-default-value-forms.md)||no|
+|`preferDefaultName`| Boolean value that decides which name will be used if no `--name` is specified during creation. If `false` it will use the fallback name (output folder name), if `true` it will use the template's `defaultName`. If no `defaultName` and no fallback name is specified and `preferDefaultName` is set to `true`, the template creation will not succeed with a `TemplateIssueDetected` exception. | If not specified, `false` is used. | no
+|`preferNameDirectory`| Boolean value, indicates whether to create a directory for the template if name is specified but an output directory is not set (instead of creating the content directly in the current directory).|If not specified, `false` is used.|no|
+|`placeholderFilename`|A filename that will be completely ignored, used to indicate that its containing directory should be copied. This allows creation of empty directory in the created template, by having a corresponding source directory containing just the placeholder file. By default, empty directories are ignored.|If not specified, a default value of `"-.-"` is used.|no|
+|`primaryOutputs`|A list of template files for further processing by the host (including post-actions). The path should contain the relative path to the file prior to the symbol based renaming that may happen during template generation. It is defined as an array of [Primary Outputs](#primary-output-definition)||no|
+
+#### Primary Output Definition
+Primary outputs define the list of template files for further processing, usually post actions.
+|Name|Description|Mandatory|
+|---|---|---|
+|`path`|should contain the relative path to the file after the template is instantiated.|yes|
+|`condition`|if the condition evaluates to `true`, the corresponding path will be added to primary outputs, if `false`, the path is ignored. If no condition is provided for a path, the condition defaults to `true`.|no|
+
+For more information on primary outputs, refer to [the article](Using-Primary-Outputs-for-Post-Actions.md).
+
+### Global custom operations and special custom operations
+This advanced configuration allows the template author to define custom actions for the template creation process. Global custom operations are scoped globally unless overridden by a more restrictive custom configuration.
+Special custom operations are scoped to the files matched by their glob pattern.
+
+Customizations allowed include:
+* Flag definitions
+* Modification operations
+
+There can only be one instance of the (global) `customOperations` section, as follows:
+```JSON
+ "customOperations": {
+ // configuration details
+ }
+```
+
+But since there can be many instances of the SpecialCustomOperations, each applicable to their glob patterns, the `specialCustomOperations` configuration section is defined as follows:
+
+```JSON
+ "specialCustomOperations": {
+ "": {
+ // configuration details
+ },
+ "": {
+ // configuration details
+ },
+ }
+```
+
+The configuration details options are identical in both situations, they only differ in the scopes they're applied in. The below sections are labelled `customOperations.`, but are equally applicable to `specialCustomOperations..`
+
+|Name|Description|Mandatory|
+|---|---|---|
+|`flagPrefix`|Overrides the default prefix to indicate a flag option in a file being processed.|no|
+|`operations`|An array that defines custom operations for processing data in the files within the scope of the configuration. These operations are applied in addition to other operations setup by default, except in the case of the conditional operation. If a custom conditional operation is defined, the default conditional operation(s) are ignored (in this scope).|no|
+|`operations.type`|Indicates the type of operation being configured. The operations currently available to configure are: - `balancedNesting` - `conditional` - `flag` - `include` - `region` - `replacement`|yes|
+|`operations.condition`|A boolean expression whose result determines whether or not to use this custom operation. If this is not provided, the operation is used.|no|
+|`operations.configuration`|The details of the operation configuration. Each type of operation has its own configuration options, as detailed below.|yes|
+
+SpecialCustomOperations can be used for adding conditions for handling files with extensions not listed in [Conditional processing and comment syntax](../docs/Conditional-processing-and-comment-syntax.md#introduction).
+
+```JSON
+{
+ "SpecialCustomOperations": {
+ "**.axml": {
+ "operations": [
+ {
+ "type": "conditional",
+ "configuration": {
+ "endif": [ "#endif", "
+ true
+
+
+
+
+
+ annotations
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/FileSystemInfoKind.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/FileSystemInfoKind.cs
new file mode 100644
index 000000000000..ac2779b3f49f
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/FileSystemInfoKind.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ ///
+ /// Defines the kind of a entry.
+ ///
+ public enum FileSystemInfoKind
+ {
+ ///
+ /// Entry is a file.
+ ///
+ File,
+
+ ///
+ /// Entry is a directory.
+ ///
+ Directory
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IDirectory.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IDirectory.cs
new file mode 100644
index 000000000000..3dcb743209d3
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IDirectory.cs
@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ ///
+ /// Defines directory entry.
+ ///
+ public interface IDirectory : IFileSystemInfo
+ {
+ ///
+ /// Enumerates the entries in the directory.
+ ///
+ /// Matching pattern for the entries, see for more details.
+ /// Matching pattern for the entries, see for more details.
+ /// The enumerator to entries in the directory.
+ IEnumerable EnumerateFileSystemInfos(string pattern, SearchOption searchOption);
+
+ ///
+ /// Enumerates the entries in the directory.
+ ///
+ /// Matching pattern for the entries, see for more details.
+ /// Matching pattern for the entries, see for more details.
+ /// The enumerator to entries in the directory.
+ IEnumerable EnumerateFiles(string pattern, SearchOption searchOption);
+
+ ///
+ /// Enumerates the entries in the directory.
+ ///
+ /// Matching pattern for the entries, see for more details.
+ /// Matching pattern for the entries, see for more details.
+ /// The enumerator to entries in the directory.
+ IEnumerable EnumerateDirectories(string pattern, SearchOption searchOption);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IFile.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IFile.cs
new file mode 100644
index 000000000000..90bb7de0ad7d
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IFile.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ ///
+ /// Defines a file entry.
+ ///
+ public interface IFile : IFileSystemInfo
+ {
+ ///
+ /// Opens the file stream for reading.
+ ///
+ /// that can be used for reading the file.
+ Stream OpenRead();
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IFileSystemInfo.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IFileSystemInfo.cs
new file mode 100644
index 000000000000..be73e30cdde1
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IFileSystemInfo.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ ///
+ /// Defines a file system entry.
+ ///
+ ///
+ ///
+ public interface IFileSystemInfo
+ {
+ ///
+ /// Returns true if file system entry exists, false otherwise.
+ ///
+ bool Exists { get; }
+
+ ///
+ /// Gets the path to file system entry inside mount point .
+ ///
+ string FullPath { get; }
+
+ ///
+ /// Gets file system entry kind.
+ ///
+ FileSystemInfoKind Kind { get; }
+
+ ///
+ /// Gets parent directory of file system entry.
+ ///
+ IDirectory? Parent { get; }
+
+ ///
+ /// Gets file system entry name.
+ ///
+ string Name { get; }
+
+ ///
+ /// Gets mount point for file system entry.
+ ///
+ IMountPoint MountPoint { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPoint.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPoint.cs
new file mode 100644
index 000000000000..a3670f1fa8e0
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPoint.cs
@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ ///
+ /// Represents abstract directory.
+ /// This could be regular folder on file system, zip file, HTTP server or anything else that can
+ /// present files in file system hierarchy.
+ ///
+ public interface IMountPoint : IDisposable
+ {
+ ///
+ /// Returns mount point URI (as received from template package provider = not normalized).
+ ///
+ string MountPointUri { get; }
+
+ ///
+ /// Returns root directory of the mount point.
+ ///
+ IDirectory Root { get; }
+
+ ///
+ /// used to create this instance.
+ ///
+ IEngineEnvironmentSettings EnvironmentSettings { get; }
+
+ ///
+ /// Gets the file info for the file in the mount point.
+ ///
+ /// The path to the file relative to mount point root.
+ ///
+ IFile? FileInfo(string path);
+
+ ///
+ /// Gets the directory info for the directory in the mount point.
+ ///
+ /// The path to the directory relative to mount point root.
+ ///
+ IDirectory? DirectoryInfo(string path);
+
+ ///
+ /// Gets the file system entry (file or directory) info for the entry in the mount point.
+ ///
+ /// The path to the file system entry relative to mount point root.
+ ///
+ IFileSystemInfo? FileSystemInfo(string path);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPointFactory.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPointFactory.cs
new file mode 100644
index 000000000000..ebc75da55f7c
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPointFactory.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ ///
+ /// Implement this factory and register it with .
+ /// Template engine calls with Uri as parameter on all factories
+ /// and use mount point from first successful factory.
+ ///
+ public interface IMountPointFactory : IIdentifiedComponent
+ {
+ ///
+ /// Tries to mount specified Uri.
+ ///
+ /// Environment to be used.
+ /// Mount points can be mounted inside each other. Pass in parent or null.
+ /// Valid that represents mount point.
+ /// Resulting mount point.
+ /// true if mount point was successfully mounted.
+ bool TryMount(IEngineEnvironmentSettings environmentSettings, IMountPoint? parent, string mountPointUri, out IMountPoint? mountPoint);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPointManager.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPointManager.cs
new file mode 100644
index 000000000000..42f6f11043a7
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Mount/IMountPointManager.cs
@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Mount
+{
+ [Obsolete("Use Microsoft.TemplateEngine.Utils.EngineEnvironmentSettingsExtensions.TryGetMountPoint")]
+ public interface IMountPointManager
+ {
+ IEngineEnvironmentSettings EnvironmentSettings { get; }
+
+ bool TryDemandMountPoint(string mountPointUri, out IMountPoint mountPoint);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/ParameterChoice.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/ParameterChoice.cs
new file mode 100644
index 000000000000..c41ed22272cb
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/ParameterChoice.cs
@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions
+{
+ ///
+ /// Represents a choice that can be assigned to a parameter.
+ ///
+ public sealed class ParameterChoice
+ {
+ public ParameterChoice(string? displayName, string? description)
+ {
+ DisplayName = displayName;
+ Description = description;
+ }
+
+ ///
+ /// Gets or sets the friendly name of the choice to be displayed to the user.
+ ///
+ public string? DisplayName { get; set; }
+
+ ///
+ /// Gets or sets the description of the choice to be displayed to the user.
+ ///
+ public string? Description { get; set; }
+
+ ///
+ /// Localizes the choice with the given localization model.
+ ///
+ public void Localize(ParameterChoiceLocalizationModel localizationModel)
+ {
+ DisplayName = localizationModel.DisplayName ?? DisplayName;
+ Description = localizationModel.Description ?? Description;
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/ParameterChoiceLocalizationModel.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/ParameterChoiceLocalizationModel.cs
new file mode 100644
index 000000000000..73cb109c218a
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/ParameterChoiceLocalizationModel.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions
+{
+ ///
+ /// Represents the data necessary for the localization of a .
+ ///
+ public sealed class ParameterChoiceLocalizationModel
+ {
+ public ParameterChoiceLocalizationModel(string? displayName, string? description)
+ {
+ DisplayName = displayName;
+ Description = description;
+ }
+
+ ///
+ /// Gets the friendly name of the choice to be displayed to the user.
+ ///
+ public string? DisplayName { get; private set; }
+
+ ///
+ /// Gets the description of the choice to be displayed to the user.
+ ///
+ public string? Description { get; private set; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/DataSource.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/DataSource.cs
new file mode 100644
index 000000000000..e8ee33cf7729
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/DataSource.cs
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters
+{
+ public enum DataSource
+ {
+ ///
+ /// Value was not set.
+ ///
+ NoSource,
+
+ ///
+ /// Those are values supplied by the host. This usually means value(s) was/were set by user.
+ ///
+ User,
+
+ ///
+ /// Value obtained via .
+ ///
+ HostDefault,
+
+ ///
+ /// Value obtained via ITemplateEngineHost.OnParameterError.
+ ///
+ [Obsolete("The value is not used anymore due to ITemplateEngineHost.OnParameterError was removed.")]
+ HostOnError,
+
+ ///
+ /// Value from template - .
+ ///
+ Default,
+
+ ///
+ /// Value from template - .
+ ///
+ DefaultIfNoValue,
+
+ ///
+ /// This corresponds to Name implicit parameter value.
+ ///
+ NameParameter,
+
+ ///
+ /// To be used in case host uses advanced object model to supply values to TemplateCreator or Generator and
+ /// wants to indicate that it used some custom logic of inferring value for parameter
+ /// (e.g. custom Host calculated value of parameter based on current context and supplied the value to template engine).
+ ///
+ HostOther,
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/IParameterDefinitionSet.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/IParameterDefinitionSet.cs
new file mode 100644
index 000000000000..2e9c4efaf8b0
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/IParameterDefinitionSet.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters;
+
+///
+/// The set of descriptors of template parameters extracted from the template.
+///
+public interface IParameterDefinitionSet : IReadOnlyList
+{
+ //
+ // Following methods are taken from the IReadOnlyDictionary
+ // That interface is not explicitly inherited as it would lead to ambiguous implementation of GetEnumerator()
+ // and hence not clean way of using in foreach. As that's more often scenario, we decided to inherit IEnumerable
+ //
+
+ /// Gets an enumerable collection that contains the keys in the read-only dictionary.
+ /// An enumerable collection that contains the keys in the read-only dictionary.
+ IEnumerable Keys { get; }
+
+ /// Gets an enumerable collection that contains the values in the read-only dictionary.
+ /// An enumerable collection that contains the values in the read-only dictionary.
+ IEnumerable Values { get; }
+
+ /// Gets the element that has the specified key in the read-only dictionary.
+ /// The key to locate.
+ /// The element that has the specified key in the read-only dictionary.
+ /// key is null.
+ /// The property is retrieved and key is not found.
+ ITemplateParameter this[string key] { get; }
+
+ /// Determines whether the read-only dictionary contains an element that has the specified key.
+ /// The key to locate.
+ /// true if the read-only dictionary contains an element that has the specified key; otherwise, false.
+ /// key is null.
+ bool ContainsKey(string key);
+
+ /// Gets the value that is associated with the specified key.
+ /// The key to locate.
+ /// When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter. This parameter is passed uninitialized.
+ /// true if the object that implements the interface contains an element that has the specified key; otherwise, false.
+ /// key is null.
+ bool TryGetValue(string key, out ITemplateParameter value);
+
+ // End of definitions pulled from IReadOnlyDictionary
+
+ ///
+ /// Casts the Parameter set to IReadOnlyDictionary.
+ ///
+ ///
+ IReadOnlyDictionary AsReadonlyDictionary();
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/IParameterSetData.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/IParameterSetData.cs
new file mode 100644
index 000000000000..a233b22c4194
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/IParameterSetData.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters;
+
+///
+/// Data model for bound and merged dataset to be used to substitute and evaluate active sections within templates.
+/// Data are possibly merged from multiple sources (default values in definition, values supplied by host, user, etc.).
+///
+public interface IParameterSetData : IReadOnlyDictionary
+{
+ ///
+ /// Descriptors for the parameters - inferred from the template.
+ ///
+ IParameterDefinitionSet ParametersDefinition { get; }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterData.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterData.cs
new file mode 100644
index 000000000000..ecace37ae821
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterData.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters;
+
+///
+/// Data model for template parameter instance data. Mainly used as input for .
+///
+public class ParameterData
+{
+ ///
+ /// Creates new instance of class.
+ ///
+ /// Descriptor of the parameter inferred from the template.
+ /// The value of the parameter derived from the instantiation context.
+ /// Source of value for template instantiation in the current context.
+ /// Indicates whether the parameter is enabled or disabled (and hence completely ignored).
+ public ParameterData(
+ ITemplateParameter parameterDefinition,
+ object? value,
+ DataSource source,
+ bool isEnabled = true)
+ {
+ ParameterDefinition = parameterDefinition;
+ Value = value;
+ DataSource = source;
+ IsEnabled = isEnabled;
+ }
+
+ ///
+ /// Descriptor of the parameter inferred from the template.
+ ///
+ public ITemplateParameter ParameterDefinition { get; }
+
+ ///
+ /// The value of the parameter derived from the instantiation context (actual source of value indicated in ).
+ ///
+ public object? Value { get; }
+
+ ///
+ /// Source of value for template instantiation in the current context.
+ ///
+ public DataSource DataSource { get; }
+
+ ///
+ /// Indicates whether the parameter is enabled or disabled (and hence completely ignored). Disabling of parameter can be achieved via
+ /// condition or constant for IsEnabled property in Template.
+ ///
+ public bool IsEnabled { get; }
+
+ public override string ToString() => $"{ParameterDefinition}: {Value?.ToString() ?? ""}";
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterDefinitionSet.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterDefinitionSet.cs
new file mode 100644
index 000000000000..941b8f7fea8a
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterDefinitionSet.cs
@@ -0,0 +1,70 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters
+{
+ ///
+ public class ParameterDefinitionSet : IParameterDefinitionSet
+ {
+ ///
+ /// Empty descriptor set.
+ ///
+ public static readonly IParameterDefinitionSet Empty = new ParameterDefinitionSet((IEnumerable?)null);
+
+ private readonly IReadOnlyDictionary _parameters;
+
+ ///
+ /// Initializes new instance of the type.
+ ///
+ ///
+ public ParameterDefinitionSet(IReadOnlyDictionary? parameters) =>
+ _parameters = parameters ?? new Dictionary();
+
+ ///
+ /// Initializes new instance of the type.
+ ///
+ ///
+ public ParameterDefinitionSet(IEnumerable? parameters)
+ : this(parameters?.ToDictionary(p => p.Name, p => p))
+ { }
+
+ ///
+ /// Initializes new instance of the type.
+ ///
+ /// Instance to be cloned.
+ public ParameterDefinitionSet(IParameterDefinitionSet other) : this(other.AsReadonlyDictionary())
+ { }
+
+ ///
+ public IEnumerable Keys => _parameters.Keys;
+
+ ///
+ public IEnumerable Values => _parameters.Values;
+
+ ///
+ public int Count => _parameters.Count;
+
+ ///
+ public ITemplateParameter this[string key] => _parameters[key];
+
+ ///
+ public ITemplateParameter this[int index] => _parameters.Values.ElementAt(index);
+
+ ///
+ public IReadOnlyDictionary AsReadonlyDictionary() => _parameters;
+
+ ///
+ public bool ContainsKey(string key) => _parameters.ContainsKey(key);
+
+ ///
+ public IEnumerator GetEnumerator() => _parameters.Values.GetEnumerator();
+
+ ///
+ public bool TryGetValue(string key, out ITemplateParameter value) => _parameters.TryGetValue(key, out value);
+
+ ///
+ IEnumerator IEnumerable.GetEnumerator() => _parameters.Values.GetEnumerator();
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterSetData.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterSetData.cs
new file mode 100644
index 000000000000..f5b61520d78e
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterSetData.cs
@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters;
+
+///
+public class ParameterSetData : IParameterSetData
+{
+ private readonly IReadOnlyDictionary _parametersData;
+
+ ///
+ /// Creates new instance of the data type.
+ ///
+ ///
+ ///
+ public ParameterSetData(IParameterDefinitionSet parameters, IReadOnlyList parameterData)
+ {
+ ParametersDefinition = new ParameterDefinitionSet(parameters.AsReadonlyDictionary());
+ _parametersData = parameterData.ToDictionary(d => d.ParameterDefinition, d => d);
+ }
+
+ ///
+ /// Creates new instance of the data type, not initialized with any actual instantiation data.
+ /// To be used for compatibility purposes in places where old dictionary parameter set was used.
+ ///
+ ///
+ public ParameterSetData(ITemplateInfo templateInfo)
+ : this(templateInfo, (IReadOnlyDictionary?)null)
+ { }
+
+ ///
+ /// Creates new instance of the data type.
+ /// To be used for compatibility purposes in places where old dictionary parameter set was used.
+ ///
+ ///
+ ///
+ public ParameterSetData(ITemplateInfo templateInfo, IReadOnlyDictionary? inputParameters)
+ : this(templateInfo, inputParameters?.ToDictionary(p => p.Key, p => (object?)p.Value))
+ { }
+
+ ///
+ /// Creates new instance of the data type.
+ /// To be used for compatibility purposes in places where old dictionary parameter set was used.
+ ///
+ ///
+ ///
+ public ParameterSetData(ITemplateInfo templateInfo, IReadOnlyDictionary? inputParameters)
+ {
+ ParametersDefinition = new ParameterDefinitionSet(templateInfo.ParameterDefinitions);
+ _parametersData = templateInfo.ParameterDefinitions.ToDictionary(p => p, p =>
+ {
+ object? value = null;
+ bool isSet = inputParameters != null && inputParameters.TryGetValue(p.Name, out value);
+ return new ParameterData(p, value, isSet ? DataSource.User : DataSource.NoSource);
+ });
+ }
+
+ ///
+ /// Empty instance.
+ ///
+ public static IParameterSetData Empty =>
+ new ParameterSetData(new ParameterDefinitionSet((IReadOnlyDictionary?)null), []);
+
+ ///
+ public IParameterDefinitionSet ParametersDefinition { get; }
+
+ ///
+ public int Count => _parametersData.Count;
+
+ ///
+ public IEnumerable Keys => _parametersData.Keys;
+
+ ///
+ public IEnumerable Values => _parametersData.Values;
+
+ ///
+ public ParameterData this[ITemplateParameter key] => _parametersData[key];
+
+ ///
+ public IEnumerator> GetEnumerator() => _parametersData.GetEnumerator();
+
+ IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+ ///
+ public bool ContainsKey(ITemplateParameter key) => _parametersData.ContainsKey(key);
+
+ ///
+ public bool TryGetValue(ITemplateParameter key, out ParameterData value) => _parametersData.TryGetValue(key, out value);
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterSetDataExtensions.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterSetDataExtensions.cs
new file mode 100644
index 000000000000..c2ab6463e903
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/Parameters/ParameterSetDataExtensions.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.Parameters;
+
+public static class ParameterSetDataExtensions
+{
+ ///
+ /// Fetches the value of parameter from the set, based on the name of the parameter.
+ ///
+ ///
+ ///
+ ///
+ public static ParameterData GetValue(this IParameterSetData data, string parameterName)
+ {
+ return data[data.ParametersDefinition[parameterName]];
+ }
+
+ ///
+ /// Attempts to fetch the value of parameter from the set, based on the name of the parameter.
+ ///
+ ///
+ ///
+ ///
+ /// True if parameter data was found. False otherwise.
+ public static bool TryGetValue(this IParameterSetData data, string parameterName, out ParameterData? parameterData)
+ {
+ parameterData = null;
+ return
+ data.ParametersDefinition.TryGetValue(parameterName, out ITemplateParameter parameter) &&
+ data.TryGetValue(parameter, out parameterData);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PhysicalFileSystem/IFileLastWriteTimeSource.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PhysicalFileSystem/IFileLastWriteTimeSource.cs
new file mode 100644
index 000000000000..e53a4ba187dc
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PhysicalFileSystem/IFileLastWriteTimeSource.cs
@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem
+{
+ [Obsolete("Use IPhysicalFileSystem properties instead.")]
+ public interface IFileLastWriteTimeSource
+ {
+ DateTime GetLastWriteTimeUtc(string file);
+
+ void SetLastWriteTimeUtc(string file, DateTime lastWriteTimeUtc);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PhysicalFileSystem/IPhysicalFileSystem.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PhysicalFileSystem/IPhysicalFileSystem.cs
new file mode 100644
index 000000000000..09a6c402fc6a
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PhysicalFileSystem/IPhysicalFileSystem.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem
+{
+ ///
+ /// Abstraction of FileSystem APIs, this allows unit tests to execute without touching hard drive.
+ /// But also allows host to not store anything on physical file system, instead everything can be
+ /// kept in memory and discarded after running.
+ ///
+ public interface IPhysicalFileSystem
+ {
+ ///
+ /// Same behavior as .
+ ///
+ bool DirectoryExists(string directory);
+
+ ///
+ /// Same behavior as .
+ ///
+ bool FileExists(string file);
+
+ ///
+ /// Same behavior as .
+ ///
+ Stream CreateFile(string path);
+
+ ///
+ /// Same behavior as .
+ ///
+ void CreateDirectory(string path);
+
+ ///
+ /// Same behavior as .
+ ///
+ string GetCurrentDirectory();
+
+ ///
+ /// Same behavior as .
+ ///
+ IEnumerable EnumerateFileSystemEntries(string directoryName, string pattern, SearchOption searchOption);
+
+ ///
+ /// Same behavior as .
+ ///
+ void FileCopy(string sourcePath, string targetPath, bool overwrite);
+
+ ///
+ /// Same behavior as .
+ ///
+ void DirectoryDelete(string path, bool recursive);
+
+ ///
+ /// Same behavior as .
+ ///
+ string ReadAllText(string path);
+
+ ///
+ /// Opens a binary file, reads the contents of the file into a byte array, and then closes the file.
+ /// Same behavior as .
+ ///
+ byte[] ReadAllBytes(string path);
+
+ ///
+ /// Same behavior as .
+ ///
+ void WriteAllText(string path, string value);
+
+ ///
+ /// Same behavior as .
+ ///
+ IEnumerable EnumerateDirectories(string path, string pattern, SearchOption searchOption);
+
+ ///
+ /// Same behavior as .
+ ///
+ IEnumerable EnumerateFiles(string path, string pattern, SearchOption searchOption);
+
+ ///
+ /// Same behavior as .
+ ///
+ Stream OpenRead(string path);
+
+ ///
+ /// Same behavior as .
+ ///
+ void FileDelete(string path);
+
+ ///
+ /// Same behavior as .
+ ///
+ FileAttributes GetFileAttributes(string file);
+
+ ///
+ /// Same behavior as .
+ ///
+ void SetFileAttributes(string file, FileAttributes attributes);
+
+ ///
+ /// Same behavior as .
+ ///
+ ///
+ /// Creates new which monitors specified path and on any changes calls callback.
+ /// To stop watching dispose returned object.
+ ///
+ IDisposable WatchFileChanges(string filePath, FileSystemEventHandler fileChanged);
+
+ ///
+ /// Gets the last write time for the in UTC.
+ /// Same behavior as .
+ ///
+ /// The file to get last write time for.
+ ///
+ DateTime GetLastWriteTimeUtc(string file);
+
+ ///
+ /// Sets the last write time for the in UTC.
+ /// Same behavior as .
+ ///
+ /// The file to set last write time for.
+ /// the time to set.
+ void SetLastWriteTimeUtc(string file, DateTime lastWriteTimeUtc);
+
+ ///
+ /// If target is a sub-path of relativeTo a relative bath from relativeTo to sub-path will be returned.
+ ///
+ /// Path to be converted to relative if possible.
+ /// Base of the relative path to be returned.
+ ///
+ string PathRelativeTo(string target, string relativeTo);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PrecedenceDefinition.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PrecedenceDefinition.cs
new file mode 100644
index 000000000000..696d4b595290
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PrecedenceDefinition.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions;
+
+///
+/// Indicates parameter defined precedence.
+///
+public enum PrecedenceDefinition
+{
+ // If enable condition is set - parameter is conditionally disabled (regardless if require condition is set or not)
+ // Conditionally required is if and only if the only require condition is set.
+
+ ///
+ /// Parameter value is unconditionally required.
+ ///
+ Required,
+
+ ///
+ /// Set if and only if only the IsRequiredCondition is set.
+ ///
+ ConditionalyRequired,
+
+ ///
+ /// Parameter value is not required from user.
+ ///
+ Optional,
+
+ ///
+ /// Parameter value is implicitly populated.
+ ///
+ Implicit,
+
+ ///
+ /// Parameter might become disabled - value would not be needed nor used in such case.
+ ///
+ ConditionalyDisabled,
+
+ ///
+ /// Parameter is disabled - it's value is not required and will not be used.
+ ///
+ Disabled,
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PublicAPI.Shipped.txt b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PublicAPI.Shipped.txt
new file mode 100644
index 000000000000..83281993f106
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PublicAPI.Shipped.txt
@@ -0,0 +1,469 @@
+#nullable enable
+const Microsoft.TemplateEngine.Abstractions.Installer.InstallerConstants.NuGetSourcesSeparator = ';' -> char
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Author = "Author" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Baseline = "Baseline" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Classification = "Classification" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Language = "Language" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Name = "Name" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.ShortName = "ShortName" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Type = "Type" -> string!
+Microsoft.TemplateEngine.Abstractions.ChangeKind
+Microsoft.TemplateEngine.Abstractions.ChangeKind.Change = 3 -> Microsoft.TemplateEngine.Abstractions.ChangeKind
+Microsoft.TemplateEngine.Abstractions.ChangeKind.Create = 0 -> Microsoft.TemplateEngine.Abstractions.ChangeKind
+Microsoft.TemplateEngine.Abstractions.ChangeKind.Delete = 1 -> Microsoft.TemplateEngine.Abstractions.ChangeKind
+Microsoft.TemplateEngine.Abstractions.ChangeKind.Overwrite = 2 -> Microsoft.TemplateEngine.Abstractions.ChangeKind
+Microsoft.TemplateEngine.Abstractions.IAllowDefaultIfOptionWithoutValue
+Microsoft.TemplateEngine.Abstractions.IBaselineInfo
+Microsoft.TemplateEngine.Abstractions.ICacheParameter
+Microsoft.TemplateEngine.Abstractions.ICacheParameter.DataType.get -> string?
+Microsoft.TemplateEngine.Abstractions.ICacheParameter.DefaultValue.get -> string?
+Microsoft.TemplateEngine.Abstractions.ICacheParameter.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ICacheParameter.DisplayName.get -> string?
+Microsoft.TemplateEngine.Abstractions.ICacheTag
+Microsoft.TemplateEngine.Abstractions.ICacheTag.Choices.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.ICacheTag.DefaultValue.get -> string?
+Microsoft.TemplateEngine.Abstractions.ICacheTag.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ICacheTag.DisplayName.get -> string?
+Microsoft.TemplateEngine.Abstractions.IComponentManager
+Microsoft.TemplateEngine.Abstractions.IComponentManager.AddComponent(System.Type! interfaceType, Microsoft.TemplateEngine.Abstractions.IIdentifiedComponent! instance) -> void
+Microsoft.TemplateEngine.Abstractions.ICreationEffects
+Microsoft.TemplateEngine.Abstractions.ICreationEffects.CreationResult.get -> Microsoft.TemplateEngine.Abstractions.ICreationResult!
+Microsoft.TemplateEngine.Abstractions.ICreationEffects.FileChanges.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ICreationEffects2
+Microsoft.TemplateEngine.Abstractions.ICreationEffects2.CreationResult.get -> Microsoft.TemplateEngine.Abstractions.ICreationResult!
+Microsoft.TemplateEngine.Abstractions.ICreationEffects2.FileChanges.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ICreationPath
+Microsoft.TemplateEngine.Abstractions.ICreationPath.Path.get -> string!
+Microsoft.TemplateEngine.Abstractions.ICreationResult
+Microsoft.TemplateEngine.Abstractions.ICreationResult.PostActions.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ICreationResult.PrimaryOutputs.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings
+Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings.Components.get -> Microsoft.TemplateEngine.Abstractions.IComponentManager!
+Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings.Environment.get -> Microsoft.TemplateEngine.Abstractions.IEnvironment!
+Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings.Host.get -> Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost!
+Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings.Paths.get -> Microsoft.TemplateEngine.Abstractions.IPathInfo!
+Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings.SettingsLoader.get -> Microsoft.TemplateEngine.Abstractions.ISettingsLoader!
+Microsoft.TemplateEngine.Abstractions.IEnvironment
+Microsoft.TemplateEngine.Abstractions.IEnvironment.ConsoleBufferWidth.get -> int
+Microsoft.TemplateEngine.Abstractions.IEnvironment.ExpandEnvironmentVariables(string! name) -> string!
+Microsoft.TemplateEngine.Abstractions.IEnvironment.GetEnvironmentVariable(string! name) -> string?
+Microsoft.TemplateEngine.Abstractions.IEnvironment.GetEnvironmentVariables() -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.IEnvironment.NewLine.get -> string!
+Microsoft.TemplateEngine.Abstractions.IFileChange
+Microsoft.TemplateEngine.Abstractions.IFileChange.ChangeKind.get -> Microsoft.TemplateEngine.Abstractions.ChangeKind
+Microsoft.TemplateEngine.Abstractions.IFileChange.Contents.get -> byte[]!
+Microsoft.TemplateEngine.Abstractions.IFileChange.TargetRelativePath.get -> string!
+Microsoft.TemplateEngine.Abstractions.IFileChange2
+Microsoft.TemplateEngine.Abstractions.IFileChange2.SourceRelativePath.get -> string!
+Microsoft.TemplateEngine.Abstractions.IGenerator
+Microsoft.TemplateEngine.Abstractions.IIdentifiedComponent
+Microsoft.TemplateEngine.Abstractions.IIdentifiedComponent.Id.get -> System.Guid
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator
+Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult
+Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult.IsLatestVersion.get -> bool
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller
+Microsoft.TemplateEngine.Abstractions.Installer.IInstallerFactory
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerConstants
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.AlreadyInstalled = 6 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.DownloadFailed = 3 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.GenericError = 5 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.InvalidPackage = 8 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.InvalidSource = 2 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.PackageNotFound = 1 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.Success = 0 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.UnsupportedRequest = 4 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.UpdateUninstallFailed = 7 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult.Error.get -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult.Success.get -> bool
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest
+Microsoft.TemplateEngine.Abstractions.Installer.InstallResult
+Microsoft.TemplateEngine.Abstractions.Installer.ISerializableInstaller
+Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData
+Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData.Details.get -> System.Collections.Generic.IReadOnlyDictionary?
+Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData.InstallerId.get -> System.Guid
+Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData.LastChangeTime.get -> System.DateTime
+Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData.MountPointUri.get -> string!
+Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData.TemplatePackageData(System.Guid installerId, string! mountPointUri, System.DateTime lastChangeTime, System.Collections.Generic.IReadOnlyDictionary? details) -> void
+Microsoft.TemplateEngine.Abstractions.Installer.UninstallResult
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult
+Microsoft.TemplateEngine.Abstractions.IParameterSet
+Microsoft.TemplateEngine.Abstractions.IParameterSymbolLocalizationModel
+Microsoft.TemplateEngine.Abstractions.IParameterSymbolLocalizationModel.Choices.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.IParameterSymbolLocalizationModel.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.IParameterSymbolLocalizationModel.DisplayName.get -> string?
+Microsoft.TemplateEngine.Abstractions.IParameterSymbolLocalizationModel.Name.get -> string!
+Microsoft.TemplateEngine.Abstractions.IPathInfo
+Microsoft.TemplateEngine.Abstractions.IPathInfo.GlobalSettingsDir.get -> string!
+Microsoft.TemplateEngine.Abstractions.IPathInfo.HostSettingsDir.get -> string!
+Microsoft.TemplateEngine.Abstractions.IPathInfo.HostVersionSettingsDir.get -> string!
+Microsoft.TemplateEngine.Abstractions.IPathInfo.UserProfileDir.get -> string!
+Microsoft.TemplateEngine.Abstractions.IPostAction
+Microsoft.TemplateEngine.Abstractions.IPostAction.ActionId.get -> System.Guid
+Microsoft.TemplateEngine.Abstractions.IPostAction.Args.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.IPostAction.ContinueOnError.get -> bool
+Microsoft.TemplateEngine.Abstractions.IPostAction.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.IPostAction.ManualInstructions.get -> string?
+Microsoft.TemplateEngine.Abstractions.IPrioritizedComponent
+Microsoft.TemplateEngine.Abstractions.IPrioritizedComponent.Priority.get -> int
+Microsoft.TemplateEngine.Abstractions.ISearchPackFilter
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.Save() -> void
+Microsoft.TemplateEngine.Abstractions.IShortNameList
+Microsoft.TemplateEngine.Abstractions.ISimpleConfigModifiers
+Microsoft.TemplateEngine.Abstractions.ITemplate
+Microsoft.TemplateEngine.Abstractions.ITemplate.IsNameAgreementWithFolderPreferred.get -> bool
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.BuiltInComponents.get -> System.Collections.Generic.IReadOnlyList<(System.Type! InterfaceType, Microsoft.TemplateEngine.Abstractions.IIdentifiedComponent! Instance)>!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.FallbackHostTemplateConfigNames.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.FileSystem.get -> Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.HostIdentifier.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.Logger.get -> Microsoft.Extensions.Logging.ILogger!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.LoggerFactory.get -> Microsoft.Extensions.Logging.ILoggerFactory!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.OnPotentiallyDestructiveChangesDetected(System.Collections.Generic.IReadOnlyList! changes, System.Collections.Generic.IReadOnlyList! destructiveChanges) -> bool
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.TryGetHostParamDefault(string! paramName, out string? value) -> bool
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.Version.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost.VirtualizeDirectory(string! path) -> void
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo.CacheParameters.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo.HasScriptRunningPostActions.get -> bool
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo.HasScriptRunningPostActions.set -> void
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo.Parameters.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo.ShortName.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateInfo.Tags.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Choices.get -> System.Collections.Generic.IReadOnlyDictionary?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.DataType.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.DefaultIfOptionWithoutValue.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.DefaultValue.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.DisplayName.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Documentation.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.IsName.get -> bool
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Name.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Priority.get -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Type.get -> string!
+Microsoft.TemplateEngine.Abstractions.Mount.FileSystemInfoKind
+Microsoft.TemplateEngine.Abstractions.Mount.FileSystemInfoKind.Directory = 1 -> Microsoft.TemplateEngine.Abstractions.Mount.FileSystemInfoKind
+Microsoft.TemplateEngine.Abstractions.Mount.FileSystemInfoKind.File = 0 -> Microsoft.TemplateEngine.Abstractions.Mount.FileSystemInfoKind
+Microsoft.TemplateEngine.Abstractions.Mount.IDirectory
+Microsoft.TemplateEngine.Abstractions.Mount.IFile
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo.Exists.get -> bool
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo.Kind.get -> Microsoft.TemplateEngine.Abstractions.Mount.FileSystemInfoKind
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPointFactory
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPointManager
+Microsoft.TemplateEngine.Abstractions.ParameterChoice
+Microsoft.TemplateEngine.Abstractions.ParameterChoice.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ParameterChoice.Description.set -> void
+Microsoft.TemplateEngine.Abstractions.ParameterChoice.DisplayName.get -> string?
+Microsoft.TemplateEngine.Abstractions.ParameterChoice.DisplayName.set -> void
+Microsoft.TemplateEngine.Abstractions.ParameterChoice.Localize(Microsoft.TemplateEngine.Abstractions.ParameterChoiceLocalizationModel! localizationModel) -> void
+Microsoft.TemplateEngine.Abstractions.ParameterChoice.ParameterChoice(string? displayName, string? description) -> void
+Microsoft.TemplateEngine.Abstractions.ParameterChoiceLocalizationModel
+Microsoft.TemplateEngine.Abstractions.ParameterChoiceLocalizationModel.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ParameterChoiceLocalizationModel.DisplayName.get -> string?
+Microsoft.TemplateEngine.Abstractions.ParameterChoiceLocalizationModel.ParameterChoiceLocalizationModel(string? displayName, string? description) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IFileLastWriteTimeSource
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.CreateDirectory(string! path) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.CreateFile(string! path) -> System.IO.Stream!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.DirectoryDelete(string! path, bool recursive) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.DirectoryExists(string! directory) -> bool
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.EnumerateDirectories(string! path, string! pattern, System.IO.SearchOption searchOption) -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.EnumerateFiles(string! path, string! pattern, System.IO.SearchOption searchOption) -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.EnumerateFileSystemEntries(string! directoryName, string! pattern, System.IO.SearchOption searchOption) -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.FileCopy(string! sourcePath, string! targetPath, bool overwrite) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.FileDelete(string! path) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.FileExists(string! file) -> bool
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.GetCurrentDirectory() -> string!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.GetFileAttributes(string! file) -> System.IO.FileAttributes
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.GetLastWriteTimeUtc(string! file) -> System.DateTime
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.OpenRead(string! path) -> System.IO.Stream!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.ReadAllBytes(string! path) -> byte[]!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.ReadAllText(string! path) -> string!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.SetFileAttributes(string! file, System.IO.FileAttributes attributes) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.SetLastWriteTimeUtc(string! file, System.DateTime lastWriteTimeUtc) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.WatchFileChanges(string! filePath, System.IO.FileSystemEventHandler! fileChanged) -> System.IDisposable!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.WriteAllText(string! path, string! value) -> void
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo.AddMatchDisposition(Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo! newDisposition) -> void
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo.Info.get -> Microsoft.TemplateEngine.Abstractions.ITemplateInfo!
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.ITemplateMatchInfo.MatchDisposition.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.Kind.get -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.MatchInfo(string! name, string? value, Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind kind) -> void
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.Name.get -> string!
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.Value.get -> string?
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.AmbiguousValue = 5 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.Exact = 0 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.InvalidName = 3 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.InvalidValue = 4 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.Mismatch = 2 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.Partial = 1 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind.SingleStartsWith = 6 -> Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchKind
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackage
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackage.LastChangeTime.get -> System.DateTime
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider.TemplatePackagesChanged -> System.Action?
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProviderFactory
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.TemplatePackage
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.TemplatePackage.LastChangeTime.get -> System.DateTime
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority.Implicit = 3 -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority.Optional = 2 -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority.Required = 0 -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority.Suggested = 1 -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+Microsoft.TemplateEngine.Abstractions.IBaselineInfo.DefaultOverrides.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.IBaselineInfo.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.IComponentManager.OfType() -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.IComponentManager.Register(System.Type! type) -> void
+Microsoft.TemplateEngine.Abstractions.IComponentManager.RegisterMany(System.Collections.Generic.IEnumerable! typeList) -> void
+Microsoft.TemplateEngine.Abstractions.IComponentManager.TryGetComponent(System.Guid id, out T? component) -> bool
+const Microsoft.TemplateEngine.Abstractions.Installer.InstallerConstants.InteractiveModeKey = "Interactive" -> string!
+const Microsoft.TemplateEngine.Abstractions.Installer.InstallerConstants.NuGetSourcesKey = "NuGetSources" -> string!
+const Microsoft.TemplateEngine.Abstractions.TemplateFiltering.MatchInfo.BuiltIn.Constraint = "Constraint" -> string!
+Microsoft.TemplateEngine.Abstractions.Components.IBindSymbolSource
+Microsoft.TemplateEngine.Abstractions.Components.IBindSymbolSource.DisplayName.get -> string!
+Microsoft.TemplateEngine.Abstractions.Components.IBindSymbolSource.GetBoundValueAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! settings, string! bindName, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Components.IBindSymbolSource.RequiresPrefixMatch.get -> bool
+Microsoft.TemplateEngine.Abstractions.Components.IBindSymbolSource.SourcePrefix.get -> string?
+Microsoft.TemplateEngine.Abstractions.Components.ISdkInfoProvider
+Microsoft.TemplateEngine.Abstractions.Components.ISdkInfoProvider.GetCurrentVersionAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Components.ISdkInfoProvider.GetInstalledVersionsAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.Components.ISdkInfoProvider.ProvideConstraintRemedySuggestion(System.Collections.Generic.IReadOnlyList! supportedVersions, System.Collections.Generic.IReadOnlyList! viableInstalledVersions) -> string!
+Microsoft.TemplateEngine.Abstractions.Components.IWorkloadsInfoProvider.GetInstalledWorkloadsAsync(System.Threading.CancellationToken token) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.Components.IWorkloadsInfoProvider.ProvideConstraintRemedySuggestion(System.Collections.Generic.IReadOnlyList! supportedWorkloads) -> string!
+Microsoft.TemplateEngine.Abstractions.Components.WorkloadInfo.Description.get -> string!
+Microsoft.TemplateEngine.Abstractions.Components.WorkloadInfo.Id.get -> string!
+Microsoft.TemplateEngine.Abstractions.Components.WorkloadInfo.WorkloadInfo(string! id, string! description) -> void
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint.DisplayName.get -> string!
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint.Evaluate(string? args) -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult!
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint.Type.get -> string!
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraintFactory
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraintFactory.CreateTemplateConstraintAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraintFactory.Type.get -> string!
+Microsoft.TemplateEngine.Abstractions.Components.IWorkloadsInfoProvider
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintInfo
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintInfo.Args.get -> string?
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintInfo.TemplateConstraintInfo(string! type, string? args) -> void
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintInfo.Type.get -> string!
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.CallToAction.get -> string?
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Constraint.get -> Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint?
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.ConstraintType.get -> string!
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.EvaluationStatus.get -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.LocalizedErrorMessage.get -> string?
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status.Allowed = 1 -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status.NotEvaluated = 0 -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status
+Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status.Restricted = 2 -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.Status
+Microsoft.TemplateEngine.Abstractions.Components.WorkloadInfo
+Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence
+Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence.Disabled = 3 -> Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence
+Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence.Implicit = 2 -> Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence
+Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence.Optional = 1 -> Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence
+Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence.Required = 0 -> Microsoft.TemplateEngine.Abstractions.EvaluatedPrecedence
+Microsoft.TemplateEngine.Abstractions.IAllowDefaultIfOptionWithoutValue.DefaultIfOptionWithoutValue.get -> string?
+Microsoft.TemplateEngine.Abstractions.IAllowDefaultIfOptionWithoutValue.DefaultIfOptionWithoutValue.set -> void
+Microsoft.TemplateEngine.Abstractions.IGenerator.ConvertParameterValueToType(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.ITemplateParameter! parameter, string! untypedValue, out bool valueResolutionError) -> object?
+Microsoft.TemplateEngine.Abstractions.IGenerator.CreateAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.ITemplate! template, Microsoft.TemplateEngine.Abstractions.IParameterSet! parameters, string! targetDirectory, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.IGenerator.CreateAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.ITemplate! template, Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData! parameters, string! targetDirectory, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.IGenerator.GetCreationEffectsAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.ITemplate! template, Microsoft.TemplateEngine.Abstractions.IParameterSet! parameters, string! targetDirectory, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.IGenerator.GetCreationEffectsAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.ITemplate! template, Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData! parameters, string! targetDirectory, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.IGenerator.GetParametersForTemplate(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.ITemplate! template) -> Microsoft.TemplateEngine.Abstractions.IParameterSet!
+Microsoft.TemplateEngine.Abstractions.IGenerator.GetTemplatesAndLangpacksFromDir(Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! source, out System.Collections.Generic.IList! localizations) -> System.Collections.Generic.IList!
+Microsoft.TemplateEngine.Abstractions.IGenerator.TryEvaluateFromString(Microsoft.Extensions.Logging.ILogger! logger, string! text, System.Collections.Generic.IDictionary! variables, out bool result, out string! evaluationError, System.Collections.Generic.HashSet? referencedVariablesKeys = null) -> bool
+Microsoft.TemplateEngine.Abstractions.IGenerator.TryGetTemplateFromConfigInfo(Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo! config, out Microsoft.TemplateEngine.Abstractions.ITemplate? template, Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo? localeConfig, Microsoft.TemplateEngine.Abstractions.Mount.IFile? hostTemplateConfigFile, string? baselineName = null) -> bool
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.Author.get -> string?
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.ConfigPlace.get -> string!
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.Identity.get -> string!
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.Locale.get -> string!
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.Name.get -> string?
+Microsoft.TemplateEngine.Abstractions.ILocalizationLocator.ParameterSymbols.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.IParameterSet.ParameterDefinitions.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.IParameterSet.ResolvedValues.get -> System.Collections.Generic.IDictionary!
+Microsoft.TemplateEngine.Abstractions.IParameterSet.TryGetParameterDefinition(string! name, out Microsoft.TemplateEngine.Abstractions.ITemplateParameter! parameter) -> bool
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.Precedence.get -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence!
+Microsoft.TemplateEngine.Abstractions.Mount.IDirectory.EnumerateDirectories(string! pattern, System.IO.SearchOption searchOption) -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Mount.IDirectory.EnumerateFiles(string! pattern, System.IO.SearchOption searchOption) -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Mount.IDirectory.EnumerateFileSystemInfos(string! pattern, System.IO.SearchOption searchOption) -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Mount.IFile.OpenRead() -> System.IO.Stream!
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo.FullPath.get -> string!
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo.MountPoint.get -> Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint!
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo.Name.get -> string!
+Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo.Parent.get -> Microsoft.TemplateEngine.Abstractions.Mount.IDirectory?
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint.DirectoryInfo(string! path) -> Microsoft.TemplateEngine.Abstractions.Mount.IDirectory?
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint.EnvironmentSettings.get -> Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings!
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint.FileInfo(string! path) -> Microsoft.TemplateEngine.Abstractions.Mount.IFile?
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint.FileSystemInfo(string! path) -> Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo?
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint.MountPointUri.get -> string!
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint.Root.get -> Microsoft.TemplateEngine.Abstractions.Mount.IDirectory!
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPointFactory.TryMount(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! environmentSettings, Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint? parent, string! mountPointUri, out Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint? mountPoint) -> bool
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPointManager.EnvironmentSettings.get -> Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings!
+Microsoft.TemplateEngine.Abstractions.Mount.IMountPointManager.TryDemandMountPoint(string! mountPointUri, out Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! mountPoint) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.Default = 4 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.DefaultIfNoValue = 5 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.HostDefault = 2 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.HostOnError = 3 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.HostOther = 7 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.NameParameter = 6 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.NoSource = 0 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.DataSource.User = 1 -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet.AsReadonlyDictionary() -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet.ContainsKey(string! key) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet.Keys.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet.this[string! key].get -> Microsoft.TemplateEngine.Abstractions.ITemplateParameter!
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet.TryGetValue(string! key, out Microsoft.TemplateEngine.Abstractions.ITemplateParameter! value) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet.Values.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData
+Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData.ParametersDefinition.get -> Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData.DataSource.get -> Microsoft.TemplateEngine.Abstractions.Parameters.DataSource
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData.IsEnabled.get -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData.ParameterData(Microsoft.TemplateEngine.Abstractions.ITemplateParameter! parameterDefinition, object? value, Microsoft.TemplateEngine.Abstractions.Parameters.DataSource source, bool isEnabled = true) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData.ParameterDefinition.get -> Microsoft.TemplateEngine.Abstractions.ITemplateParameter!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData.Value.get -> object?
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.AsReadonlyDictionary() -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.ContainsKey(string! key) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.Count.get -> int
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.GetEnumerator() -> System.Collections.Generic.IEnumerator!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.Keys.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.ParameterDefinitionSet(Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet! other) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.ParameterDefinitionSet(System.Collections.Generic.IEnumerable? parameters) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.ParameterDefinitionSet(System.Collections.Generic.IReadOnlyDictionary? parameters) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.this[int index].get -> Microsoft.TemplateEngine.Abstractions.ITemplateParameter!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.this[string! key].get -> Microsoft.TemplateEngine.Abstractions.ITemplateParameter!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.TryGetValue(string! key, out Microsoft.TemplateEngine.Abstractions.ITemplateParameter! value) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.Values.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.ContainsKey(Microsoft.TemplateEngine.Abstractions.ITemplateParameter! key) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.Count.get -> int
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.GetEnumerator() -> System.Collections.Generic.IEnumerator>!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.Keys.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.ParametersDefinition.get -> Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.ParameterSetData(Microsoft.TemplateEngine.Abstractions.ITemplateInfo! templateInfo) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.ParameterSetData(Microsoft.TemplateEngine.Abstractions.ITemplateInfo! templateInfo, System.Collections.Generic.IReadOnlyDictionary? inputParameters) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.ParameterSetData(Microsoft.TemplateEngine.Abstractions.ITemplateInfo! templateInfo, System.Collections.Generic.IReadOnlyDictionary? inputParameters) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.ParameterSetData(Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet! parameters, System.Collections.Generic.IReadOnlyList! parameterData) -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.this[Microsoft.TemplateEngine.Abstractions.ITemplateParameter! key].get -> Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData!
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.TryGetValue(Microsoft.TemplateEngine.Abstractions.ITemplateParameter! key, out Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData! value) -> bool
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.Values.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IFileLastWriteTimeSource.GetLastWriteTimeUtc(string! file) -> System.DateTime
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IFileLastWriteTimeSource.SetLastWriteTimeUtc(string! file, System.DateTime lastWriteTimeUtc) -> void
+Microsoft.TemplateEngine.Abstractions.PhysicalFileSystem.IPhysicalFileSystem.PathRelativeTo(string! target, string! relativeTo) -> string!
+Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult.LatestVersion.get -> string?
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller.CanInstallAsync(Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest! installationRequest, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller.Factory.get -> Microsoft.TemplateEngine.Abstractions.Installer.IInstallerFactory!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller.GetLatestVersionAsync(System.Collections.Generic.IEnumerable! templatePackages, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider! provider, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller.InstallAsync(Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest! installRequest, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider! provider, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller.UninstallAsync(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider! provider, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstaller.UpdateAsync(Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest! updateRequest, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider! provider, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstallerFactory.CreateInstaller(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! settings, string! installPath) -> Microsoft.TemplateEngine.Abstractions.Installer.IInstaller!
+Microsoft.TemplateEngine.Abstractions.Installer.IInstallerFactory.Name.get -> string!
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult.ErrorMessage.get -> string?
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult.InstallerOperationResult(Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode error, string? errorMessage, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage? templatePackage = null) -> void
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult.InstallerOperationResult(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! managedTemplatePackage) -> void
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.Details.get -> System.Collections.Generic.Dictionary!
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.DisplayName.get -> string!
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.Force.get -> bool
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.InstallerName.get -> string?
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.InstallRequest(string! identifier, string? version = null, string? installerName = null, System.Collections.Generic.Dictionary? details = null, bool force = false) -> void
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.PackageIdentifier.get -> string!
+Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.Version.get -> string?
+Microsoft.TemplateEngine.Abstractions.Installer.InstallResult.InstallRequest.get -> Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest!
+Microsoft.TemplateEngine.Abstractions.Installer.ISerializableInstaller.Deserialize(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider! provider, Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData! data) -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage!
+Microsoft.TemplateEngine.Abstractions.Installer.ISerializableInstaller.Serialize(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage) -> Microsoft.TemplateEngine.Abstractions.Installer.TemplatePackageData!
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest.TemplatePackage.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage!
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest.UpdateRequest(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, string! targetVersion) -> void
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest.Version.get -> string!
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult.UpdateRequest.get -> Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest!
+Microsoft.TemplateEngine.Abstractions.ISearchPackFilter.ShouldPackBeFiltered(string! candidatePackName, string! candidatePackVersion) -> bool
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.AddMountPoint(Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! mountPoint) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.AddProbingPath(string! probeIn) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.Components.get -> Microsoft.TemplateEngine.Abstractions.IComponentManager!
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.EnvironmentSettings.get -> Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings!
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.FindBestHostTemplateConfigFile(Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo! config) -> Microsoft.TemplateEngine.Abstractions.Mount.IFile!
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.GetTemplates(System.Collections.Generic.HashSet! templates) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.LoadTemplate(Microsoft.TemplateEngine.Abstractions.ITemplateInfo! info, string! baselineName) -> Microsoft.TemplateEngine.Abstractions.ITemplate!
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.MountPoints.get -> System.Collections.Generic.IEnumerable!
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.ReleaseMountPoint(Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! mountPoint) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.RemoveMountPoint(Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! mountPoint) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.RemoveMountPoints(System.Collections.Generic.IEnumerable! mountPoints) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.TryGetFileFromIdAndPath(System.Guid mountPointId, string! place, out Microsoft.TemplateEngine.Abstractions.Mount.IFile! file, out Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! mountPoint) -> bool
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.TryGetMountPointFromPlace(string! mountPointPlace, out Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! mountPoint) -> bool
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.TryGetMountPointInfo(System.Guid mountPointId, out object! info) -> bool
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.WriteTemplateCache(System.Collections.Generic.IList! templates, string! locale) -> void
+Microsoft.TemplateEngine.Abstractions.ISettingsLoader.WriteTemplateCache(System.Collections.Generic.IList! templates, string! locale, bool hasContentChanges) -> void
+Microsoft.TemplateEngine.Abstractions.IShortNameList.ShortNameList.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ISimpleConfigModifiers.BaselineName.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplate.Configuration.get -> Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo!
+Microsoft.TemplateEngine.Abstractions.ITemplate.Generator.get -> Microsoft.TemplateEngine.Abstractions.IGenerator!
+Microsoft.TemplateEngine.Abstractions.ITemplate.LocaleConfiguration.get -> Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo?
+Microsoft.TemplateEngine.Abstractions.ITemplateParameter.AllowMultipleValues.get -> bool
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition.ConditionalyDisabled = 4 -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition.ConditionalyRequired = 1 -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition.Disabled = 5 -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition.Implicit = 3 -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition.Optional = 2 -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition.Required = 0 -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.DisplayName.get -> string!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.GetDetails() -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.Identifier.get -> string!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.Installer.get -> Microsoft.TemplateEngine.Abstractions.Installer.IInstaller!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.IsLocalPackage.get -> bool
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.ManagedProvider.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage.Version.get -> string?
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider.GetLatestVersionsAsync(System.Collections.Generic.IEnumerable! templatePackages, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider.InstallAsync(System.Collections.Generic.IEnumerable! installRequests, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider.UninstallAsync(System.Collections.Generic.IEnumerable! templatePackages, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackageProvider.UpdateAsync(System.Collections.Generic.IEnumerable! updateRequests, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackage.MountPointUri.get -> string!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackage.Provider.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider.Factory.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProviderFactory!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider.GetAllTemplatePackagesAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProviderFactory.CreateProvider(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! settings) -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProviderFactory.DisplayName.get -> string!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.TemplatePackage.MountPointUri.get -> string!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.TemplatePackage.Provider.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider!
+Microsoft.TemplateEngine.Abstractions.TemplatePackage.TemplatePackage.TemplatePackage(Microsoft.TemplateEngine.Abstractions.TemplatePackage.ITemplatePackageProvider! provider, string! mountPointUri, System.DateTime lastChangeTime) -> void
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.CanBeRequired.get -> bool
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.IsEnabledCondition.get -> string?
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.IsRequired.get -> bool
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.IsRequiredCondition.get -> string?
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.PrecedenceDefinition.get -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.TemplateParameterPrecedence(Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition precedenceDefinition, string? isRequiredCondition = null, string? isEnabledCondition = null, bool isRequired = false) -> void
+Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedenceExtensions
+override Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult.TemplatePackage.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage!
+override Microsoft.TemplateEngine.Abstractions.Installer.UninstallResult.TemplatePackage.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage!
+override Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData.ToString() -> string!
+static Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.CreateAllowed(Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint! constraint) -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult!
+static Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.CreateEvaluationFailure(Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint! constraint, string! localizedErrorMessage, string? cta = null) -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult!
+static Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.CreateInitializationFailure(string! type, string! localizedErrorMessage, string? cta = null) -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult!
+static Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult.CreateRestricted(Microsoft.TemplateEngine.Abstractions.Constraints.ITemplateConstraint! constraint, string! localizedErrorMessage, string? cta = null) -> Microsoft.TemplateEngine.Abstractions.Constraints.TemplateConstraintResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult.CreateSuccess(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, string? version, bool isLatest) -> Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.UninstallResult.CreateFailure(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode error, string! localizedFailureMessage) -> Microsoft.TemplateEngine.Abstractions.Installer.UninstallResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.UninstallResult.CreateSuccess(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage) -> Microsoft.TemplateEngine.Abstractions.Installer.UninstallResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult.FromInstallResult(Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest! request, Microsoft.TemplateEngine.Abstractions.Installer.InstallResult! installResult) -> Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult!
+static Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedenceExtensions.ToPrecedenceDefinition(this Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority priority) -> Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition
+static Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedenceExtensions.ToTemplateParameterPrecedence(this Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority priority) -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence!
+static Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedenceExtensions.ToTemplateParameterPriority(this Microsoft.TemplateEngine.Abstractions.PrecedenceDefinition precedenceDefinition) -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPriority
+static readonly Microsoft.TemplateEngine.Abstractions.Parameters.ParameterDefinitionSet.Empty -> Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet!
+static readonly Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence.Default -> Microsoft.TemplateEngine.Abstractions.TemplateParameterPrecedence!
+virtual Microsoft.TemplateEngine.Abstractions.Installer.InstallerOperationResult.TemplatePackage.get -> Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage?
+override Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest.ToString() -> string!
+
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PublicAPI.Unshipped.txt b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000000..c5812ae7b1b7
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/PublicAPI.Unshipped.txt
@@ -0,0 +1,76 @@
+Microsoft.TemplateEngine.Abstractions.IExtendedTemplateLocator
+Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult.Vulnerabilities.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode.VulnerablePackage = 9 -> Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode
+Microsoft.TemplateEngine.Abstractions.Installer.InstallResult.Vulnerabilities.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult.Vulnerabilities.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo.AdvisoryUris.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo.AdvisoryUris.init -> void
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo.Severity.get -> int
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo.Severity.init -> void
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo.VulnerabilityInfo() -> void
+Microsoft.TemplateEngine.Abstractions.Installer.VulnerabilityInfo.VulnerabilityInfo(int Severity, System.Collections.Generic.IReadOnlyList! AdvisoryUris) -> void
+Microsoft.TemplateEngine.Abstractions.ITemplate.Localization.get -> Microsoft.TemplateEngine.Abstractions.ILocalizationLocator?
+Microsoft.TemplateEngine.Abstractions.ITemplate.TemplateSourceRoot.get -> Microsoft.TemplateEngine.Abstractions.Mount.IDirectory!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.PreferDefaultName.get -> bool
+Microsoft.TemplateEngine.Abstractions.IValidationInfo.IsValid.get -> bool
+Microsoft.TemplateEngine.Abstractions.IVariableCollection
+Microsoft.TemplateEngine.Abstractions.IVariableCollection.Parent.get -> Microsoft.TemplateEngine.Abstractions.IVariableCollection?
+Microsoft.TemplateEngine.Abstractions.IVariableCollection.Parent.set -> void
+Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetDataExtensions
+static Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult.CreateFailure(Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode error, string! localizedFailureMessage, System.Collections.Generic.IReadOnlyList! vulnerabilities) -> Microsoft.TemplateEngine.Abstractions.Installer.CheckUpdateResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.InstallResult.CreateFailure(Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest! request, Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode error, string! localizedFailureMessage, System.Collections.Generic.IReadOnlyList! vulnerabilities) -> Microsoft.TemplateEngine.Abstractions.Installer.InstallResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.InstallResult.CreateSuccess(Microsoft.TemplateEngine.Abstractions.Installer.InstallRequest! request, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, System.Collections.Generic.IReadOnlyList! vulnerabilities) -> Microsoft.TemplateEngine.Abstractions.Installer.InstallResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult.CreateFailure(Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest! request, Microsoft.TemplateEngine.Abstractions.Installer.InstallerErrorCode error, string! localizedFailureMessage, System.Collections.Generic.IReadOnlyList! vulnerabilities) -> Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult!
+static Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult.CreateSuccess(Microsoft.TemplateEngine.Abstractions.Installer.UpdateRequest! request, Microsoft.TemplateEngine.Abstractions.TemplatePackage.IManagedTemplatePackage! templatePackage, System.Collections.Generic.IReadOnlyList! vulnerabilities) -> Microsoft.TemplateEngine.Abstractions.Installer.UpdateResult!
+static Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetData.Empty.get -> Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData!
+static Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetDataExtensions.GetValue(this Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData! data, string! parameterName) -> Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData!
+static Microsoft.TemplateEngine.Abstractions.Parameters.ParameterSetDataExtensions.TryGetValue(this Microsoft.TemplateEngine.Abstractions.Parameters.IParameterSetData! data, string! parameterName, out Microsoft.TemplateEngine.Abstractions.Parameters.ParameterData? parameterData) -> bool
+Microsoft.TemplateEngine.Abstractions.IGenerator.GetTemplatesFromMountPointAsync(Microsoft.TemplateEngine.Abstractions.Mount.IMountPoint! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!>!
+Microsoft.TemplateEngine.Abstractions.IGenerator.LoadTemplateAsync(Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings! settings, Microsoft.TemplateEngine.Abstractions.ITemplateLocator! config, string? baselineName = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
+Microsoft.TemplateEngine.Abstractions.IExtendedTemplateLocator.HostConfigPlace.get -> string?
+Microsoft.TemplateEngine.Abstractions.IExtendedTemplateLocator.LocaleConfigPlace.get -> string?
+Microsoft.TemplateEngine.Abstractions.IScanTemplateInfo
+Microsoft.TemplateEngine.Abstractions.IScanTemplateInfo.HostConfigFiles.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.IScanTemplateInfo.Localizations.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.ITemplate.HostSpecificConfiguration.get -> Microsoft.TemplateEngine.Abstractions.Mount.IFileSystemInfo?
+Microsoft.TemplateEngine.Abstractions.ITemplateLocator
+Microsoft.TemplateEngine.Abstractions.ITemplateLocator.ConfigPlace.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateLocator.GeneratorId.get -> System.Guid
+Microsoft.TemplateEngine.Abstractions.ITemplateLocator.MountPointUri.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Author.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.BaselineInfo.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Classifications.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Constraints.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.DefaultName.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Description.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.GroupIdentity.get -> string?
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Identity.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Name.get -> string!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.ParameterDefinitions.get -> Microsoft.TemplateEngine.Abstractions.Parameters.IParameterDefinitionSet!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.PostActions.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.Precedence.get -> int
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.ShortNameList.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.TagsCollection.get -> System.Collections.Generic.IReadOnlyDictionary!
+Microsoft.TemplateEngine.Abstractions.ITemplateMetadata.ThirdPartyNotices.get -> string?
+Microsoft.TemplateEngine.Abstractions.IValidationEntry
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.Code.get -> string!
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.ErrorLocation() -> void
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.Filename.get -> string!
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.Filename.init -> void
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.LineNumber.get -> int
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.LineNumber.init -> void
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.Position.get -> int
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation.Position.init -> void
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorMessage.get -> string!
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.Location.get -> Microsoft.TemplateEngine.Abstractions.IValidationEntry.ErrorLocation?
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.Severity.get -> Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel.Error = 3 -> Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel.Info = 1 -> Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel.None = 0 -> Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel
+Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel.Warning = 2 -> Microsoft.TemplateEngine.Abstractions.IValidationEntry.SeverityLevel
+Microsoft.TemplateEngine.Abstractions.IValidationInfo
+Microsoft.TemplateEngine.Abstractions.IValidationInfo.ValidationErrors.get -> System.Collections.Generic.IReadOnlyList!
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/ITemplateMatchInfo.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/ITemplateMatchInfo.cs
new file mode 100644
index 000000000000..6ddc678f3ecc
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/ITemplateMatchInfo.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplateFiltering
+{
+ ///
+ /// Template with information about matching the filters.
+ ///
+ public interface ITemplateMatchInfo
+ {
+ ///
+ /// Gets the template the filters applied to.
+ ///
+ ITemplateInfo Info { get; }
+
+ ///
+ /// Gets match information for the filters applied to template.
+ ///
+ IReadOnlyList MatchDisposition { get; }
+
+ ///
+ /// Adds the match information.
+ ///
+ ///
+ void AddMatchDisposition(MatchInfo newDisposition);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/MatchInfo.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/MatchInfo.cs
new file mode 100644
index 000000000000..f16470f5b718
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/MatchInfo.cs
@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions.Constraints;
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplateFiltering
+{
+ ///
+ /// Represents match information for the filter applied to template.
+ ///
+ public class MatchInfo
+ {
+ ///
+ /// Creates instance.
+ ///
+ /// the name for the match. See default names in .
+ /// the value matched for.
+ /// the match kind between value and .
+ public MatchInfo(string name, string? value, MatchKind kind)
+ {
+ _ = string.IsNullOrWhiteSpace(name) ? throw new ArgumentException($"{nameof(name)} should not be null or empty") : false;
+
+ Name = name;
+ Value = value;
+ Kind = kind;
+ }
+
+ ///
+ /// Defines the match status.
+ ///
+ public MatchKind Kind { get; }
+
+ ///
+ /// Gets the name of the match.
+ /// For default filter names, see ).
+ ///
+ public string Name { get; }
+
+ ///
+ /// Gets the value provided to match for.
+ ///
+ public string? Value { get; }
+
+ ///
+ /// Frequently used filter names. They are also used by Utils.WellKnownSearchFilters.
+ ///
+ public static class BuiltIn
+ {
+ ///
+ /// Template name .
+ ///
+ public const string Name = "Name";
+
+ ///
+ /// Template short names .
+ ///
+ public const string ShortName = "ShortName";
+
+ ///
+ /// Template classifications .
+ ///
+ public const string Classification = "Classification";
+
+ ///
+ /// Template language ( named "language").
+ ///
+ public const string Language = "Language";
+
+ ///
+ /// Template type ( named "type").
+ ///
+ public const string Type = "Type";
+
+ ///
+ /// Template baseline names .
+ ///
+ public const string Baseline = "Baseline";
+
+ ///
+ /// Template author .
+ ///
+ public const string Author = "Author";
+
+ ///
+ /// Prefix used for matching.
+ /// The full name is 'Constraint.<constraint type>'.
+ ///
+ public const string Constraint = "Constraint";
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/MatchKind.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/MatchKind.cs
new file mode 100644
index 000000000000..3ca6720d4ffe
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateFiltering/MatchKind.cs
@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplateFiltering
+{
+ ///
+ /// Defines the match kind: how the filter with its input values matches the property(ies) of .
+ ///
+ public enum MatchKind
+ {
+ ///
+ /// The filter exactly matches the value of .
+ ///
+ Exact,
+
+ ///
+ /// The filter partially matches the value of .
+ /// For example, contains the value of the filter but not equal to it.
+ ///
+ Partial,
+
+ ///
+ /// The filter does not match the value of .
+ /// Example: the filter is checking and the parameter name is not defined in .
+ ///
+ Mismatch,
+
+ ///
+ /// The input passed to the filter is incorrect, impossible to identify property of to check.
+ /// Example: the filter is checking and the parameter name is not defined in .
+ ///
+ InvalidName,
+
+ ///
+ /// The input passed to the filter is incorrect: the value is different format that is supported by property.
+ /// Example: the filter is checking and the parameter is boolean but value to match with is string.
+ ///
+ InvalidValue,
+
+ [Obsolete("This value will be removed in next release, use + " + nameof(MatchKind.Mismatch) + " or " + nameof(MatchKind.InvalidValue) + " instead")]
+ AmbiguousValue,
+
+ [Obsolete("This value will be removed in next release, use + " + nameof(MatchKind.Mismatch) + " or " + nameof(MatchKind.InvalidValue) + " instead")]
+ SingleStartsWith
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/IManagedTemplatePackage.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/IManagedTemplatePackage.cs
new file mode 100644
index 000000000000..2188d8cebb2f
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/IManagedTemplatePackage.cs
@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions.Installer;
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplatePackage
+{
+ ///
+ /// Represents the package that can be managed by . can additionally install, update and uninstall template package.
+ ///
+ public interface IManagedTemplatePackage : ITemplatePackage
+ {
+ ///
+ /// Gets the name to be used when displaying template package in UI.
+ ///
+ string DisplayName { get; }
+
+ ///
+ /// Gets the identifier of template package.
+ /// Identifier should be unique in scope of that manages the .
+ ///
+ ///
+ /// This can be NuGet PackageId, path to .nupkg, folder name, depends on implementation.
+ ///
+ string Identifier { get; }
+
+ ///
+ /// Gets that installed the template package.
+ /// This serves as helper for grouping template package by installer so caller doesn't need to keep track of installer->template package relation.
+ ///
+ IInstaller Installer { get; }
+
+ ///
+ /// Gets that manages the template package.
+ /// This serves as helper for grouping packages by
+ /// so caller doesn't need to keep track of "managed provider"->"managed package" relation.
+ ///
+ IManagedTemplatePackageProvider ManagedProvider { get; }
+
+ ///
+ /// Gets the version of the template package.
+ ///
+ string? Version { get; }
+
+ ///
+ /// Indicates whether package was installed from local source (e.g. local extracted folder, local nuget etc.).
+ ///
+ bool IsLocalPackage { get; }
+
+ ///
+ /// Gets additional details about template package. The details depend on implementation.
+ ///
+ IReadOnlyDictionary GetDetails();
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/IManagedTemplatePackageProvider.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/IManagedTemplatePackageProvider.cs
new file mode 100644
index 000000000000..26ee140d58f9
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/IManagedTemplatePackageProvider.cs
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions.Installer;
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplatePackage
+{
+ ///
+ /// The provider is responsible for managing s.
+ /// Besides base functionality of , it adds ability to install, update and uninstall template packages.
+ ///
+ ///
+ /// The keeps track of template packages managed by the provider. The actual installation is done by implementations.
+ ///
+ public interface IManagedTemplatePackageProvider : ITemplatePackageProvider
+ {
+ ///
+ /// Gets the latest version for the template packages.
+ ///
+ /// List of to get latest version for.
+ ///
+ /// List of containing the check results.
+ Task> GetLatestVersionsAsync(IEnumerable templatePackages, CancellationToken cancellationToken);
+
+ ///
+ /// Updates the template packages given in to specified version.
+ ///
+ /// List of to be processed.
+ ///
+ /// List of with update results.
+ Task> UpdateAsync(IEnumerable updateRequests, CancellationToken cancellationToken);
+
+ ///
+ /// Uninstalls the template packages.
+ ///
+ /// list of s to be uninstalled.
+ ///
+ /// List of with uninstall results.
+ Task> UninstallAsync(IEnumerable templatePackages, CancellationToken cancellationToken);
+
+ ///
+ /// Installs new based on data.
+ /// All s are considered via and if only 1
+ /// returns . is executed and result is returned.
+ ///
+ /// Contains the list of to perform.
+ ///
+ /// List of with installation results.
+ Task> InstallAsync(IEnumerable installRequests, CancellationToken cancellationToken);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackage.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackage.cs
new file mode 100644
index 000000000000..d22e6ce7884e
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackage.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions.Mount;
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplatePackage
+{
+ ///
+ /// Represents the template package.
+ /// Template package is a folder, .nupkg or other container that can contain single or multiple templates.
+ /// See for more information.
+ ///
+ public interface ITemplatePackage
+ {
+ ///
+ /// Gets the last changed time for the template package.
+ /// To avoid scanning for changes every time, template engine is caching templates from
+ /// template packages, this timestamp is used to invalidate content and re-scan this template package.
+ ///
+ DateTime LastChangeTime { get; }
+
+ ///
+ /// Gets mount point URI - unique location of template package.
+ /// This can be full URI like file://, http:// or simply file path.
+ ///
+ ///
+ /// Supported mount points are defined in implementations.
+ ///
+ string MountPointUri { get; }
+
+ ///
+ /// Gets the that created the template package.
+ /// This is mostly helper for grouping packages by provider
+ /// so caller doesn't need to keep track of provider->package relation.
+ ///
+ ITemplatePackageProvider Provider { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackageProvider.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackageProvider.cs
new file mode 100644
index 000000000000..349affcb5473
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackageProvider.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplatePackage
+{
+ ///
+ /// Provides set of s available to the host.
+ ///
+ public interface ITemplatePackageProvider
+ {
+ ///
+ /// Raised when template packages have been changed. Indicates that caller should refresh the list of template packages in use.
+ ///
+ event Action? TemplatePackagesChanged;
+
+ ///
+ /// Gets that created the provider.
+ ///
+ ITemplatePackageProviderFactory Factory { get; }
+
+ ///
+ /// Gets the list of template packages available for the provider.
+ ///
+ ///
+ /// The list of s.
+ Task> GetAllTemplatePackagesAsync(CancellationToken cancellationToken);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackageProviderFactory.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackageProviderFactory.cs
new file mode 100644
index 000000000000..093e69991489
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/ITemplatePackageProviderFactory.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplatePackage
+{
+ ///
+ /// Factory responsible for creating or .
+ /// This is registered with either via or
+ /// .
+ ///
+ public interface ITemplatePackageProviderFactory : IIdentifiedComponent
+ {
+ ///
+ /// Gets the readable name of the factory.
+ /// This is used for two reasons:
+ /// 1) To show user which provider is source of template packages (when debug/verbose flag is set)
+ /// 2) To allow the user to pick specific provider to install templates to.
+ ///
+ string DisplayName { get; }
+
+ ///
+ /// Creates new provider with specified environment, the provider may also implement .
+ ///
+ ITemplatePackageProvider CreateProvider(IEngineEnvironmentSettings settings);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/TemplatePackage.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/TemplatePackage.cs
new file mode 100644
index 000000000000..32194c1f8c9e
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplatePackage/TemplatePackage.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions.TemplatePackage
+{
+ ///
+ /// Basic implementation so each
+ /// doesn't need to re-implement it.
+ ///
+ public class TemplatePackage : ITemplatePackage
+ {
+ public TemplatePackage(ITemplatePackageProvider provider, string mountPointUri, DateTime lastChangeTime)
+ {
+ Provider = provider;
+ MountPointUri = mountPointUri;
+ LastChangeTime = lastChangeTime;
+ }
+
+ ///
+ public ITemplatePackageProvider Provider { get; }
+
+ ///
+ public string MountPointUri { get; }
+
+ ///
+ public DateTime LastChangeTime { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPrecedence.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPrecedence.cs
new file mode 100644
index 000000000000..e7c2e35f023f
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPrecedence.cs
@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions;
+
+///
+/// Indication of template parameter precedence and conditions that could influence it.
+///
+public class TemplateParameterPrecedence
+{
+ ///
+ /// Default optional precedence.
+ ///
+ public static readonly TemplateParameterPrecedence Default = new(PrecedenceDefinition.Optional);
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public TemplateParameterPrecedence(
+ PrecedenceDefinition precedenceDefinition,
+ string? isRequiredCondition = null,
+ string? isEnabledCondition = null,
+ bool isRequired = false)
+ {
+ PrecedenceDefinition = precedenceDefinition;
+ IsRequiredCondition = isRequiredCondition;
+ IsEnabledCondition = isEnabledCondition;
+ IsRequired = isRequired;
+ VerifyConditions();
+ }
+
+ ///
+ /// Actual precedence definition - can be used to sort parameters (e.g. for tab completion purposes).
+ ///
+ public PrecedenceDefinition PrecedenceDefinition { get; }
+
+ ///
+ /// IsRequiredCondition value - if it was specified in template.
+ ///
+ public string? IsRequiredCondition { get; }
+
+ ///
+ /// IsEnabledCondition value - if it was specified in template.
+ ///
+ public string? IsEnabledCondition { get; }
+
+ ///
+ /// Indicates whether parameter is unconditionally required.
+ ///
+ public bool IsRequired { get; }
+
+ ///
+ /// Indicates whether parameter might be required (depending on values of other parameters).
+ ///
+ public bool CanBeRequired =>
+ PrecedenceDefinition == PrecedenceDefinition.Required ||
+ !string.IsNullOrEmpty(IsRequiredCondition) ||
+ IsRequired;
+
+ private void VerifyConditions()
+ {
+ // If enable condition is set - parameter is conditionally disabled (regardless if require condition is set or not)
+ // Conditionally required is if and only if the only require condition is set
+
+ if (!(string.IsNullOrEmpty(IsRequiredCondition) ^ PrecedenceDefinition == PrecedenceDefinition.ConditionalyRequired
+ ||
+ !string.IsNullOrEmpty(IsEnabledCondition) ^ PrecedenceDefinition == PrecedenceDefinition.ConditionalyDisabled)
+ &&
+ !(!string.IsNullOrEmpty(IsRequiredCondition) && !string.IsNullOrEmpty(IsEnabledCondition) && PrecedenceDefinition == PrecedenceDefinition.ConditionalyDisabled))
+ {
+ // TODO: localize
+ throw new ArgumentException("Mismatched precedence definition");
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPrecedenceExtensions.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPrecedenceExtensions.cs
new file mode 100644
index 000000000000..1ef2c4b3744a
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPrecedenceExtensions.cs
@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions;
+
+public static class TemplateParameterPrecedenceExtensions
+{
+ ///
+ /// Converts legacy parameter priority to the PrecedenceDefinition.
+ ///
+ ///
+ ///
+ ///
+ [Obsolete("TemplateParameterPriority is Obsolete and should be replaced with PrecedenceDefinition.")]
+ public static PrecedenceDefinition ToPrecedenceDefinition(this TemplateParameterPriority priority)
+ {
+ return priority switch
+ {
+ TemplateParameterPriority.Required => PrecedenceDefinition.Required,
+ TemplateParameterPriority.Optional => PrecedenceDefinition.Optional,
+ TemplateParameterPriority.Implicit => PrecedenceDefinition.Implicit,
+ TemplateParameterPriority.Suggested => throw new NotImplementedException(),
+ _ => throw new ArgumentOutOfRangeException(nameof(priority), priority, null),
+ };
+ }
+
+ ///
+ /// Converts legacy parameter priority to the TemplateParameterPrecedence.
+ ///
+ ///
+ ///
+ [Obsolete("TemplateParameterPriority is Obsolete and should be replaced with PrecedenceDefinition.")]
+ public static TemplateParameterPrecedence ToTemplateParameterPrecedence(this TemplateParameterPriority priority)
+ {
+ return new TemplateParameterPrecedence(priority.ToPrecedenceDefinition(), null, null);
+ }
+
+ ///
+ /// Converts the PrecedenceDefinition to legacy TemplateParameterPriority.
+ ///
+ ///
+ ///
+ ///
+ [Obsolete("TemplateParameterPriority is Obsolete and should be replaced with PrecedenceDefinition.")]
+ public static TemplateParameterPriority ToTemplateParameterPriority(this PrecedenceDefinition precedenceDefinition)
+ {
+ return precedenceDefinition switch
+ {
+ PrecedenceDefinition.Required => TemplateParameterPriority.Required,
+ PrecedenceDefinition.Optional => TemplateParameterPriority.Optional,
+ PrecedenceDefinition.Implicit => TemplateParameterPriority.Implicit,
+ _ => TemplateParameterPriority.Optional,
+ };
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPriority.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPriority.cs
new file mode 100644
index 000000000000..d1c09692a5fc
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Abstractions/TemplateParameterPriority.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Abstractions
+{
+ ///
+ /// Defines the priority of a template parameter.
+ ///
+ [Obsolete("Use Precedence instead.")]
+ public enum TemplateParameterPriority
+ {
+ ///
+ /// The parameter is mandatory.
+ ///
+ Required,
+
+ [Obsolete("the value was never used and is deprecated.")]
+ Suggested,
+
+ ///
+ /// The parameter is optional.
+ ///
+ Optional,
+
+ ///
+ /// The parameter is implicit (built-in).
+ ///
+ Implicit
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IEncodingConfig.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IEncodingConfig.cs
new file mode 100644
index 000000000000..6a4f88433017
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IEncodingConfig.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IEncodingConfig
+ {
+ Encoding Encoding { get; }
+
+ ITokenTrie LineEndings { get; }
+
+ IReadOnlyList VariableKeys { get; }
+
+ IReadOnlyList> VariableValues { get; }
+
+ ITokenTrie Variables { get; }
+
+ ITokenTrie Whitespace { get; }
+
+ ITokenTrie WhitespaceOrLineEnding { get; }
+
+ object this[int index] { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IEngineConfig.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IEngineConfig.cs
new file mode 100644
index 000000000000..66dba22e6b4d
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IEngineConfig.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Logging;
+using Microsoft.TemplateEngine.Abstractions;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IEngineConfig
+ {
+ ILogger Logger { get; }
+
+ IReadOnlyList LineEndings { get; }
+
+ string VariableFormatString { get; }
+
+ IVariableCollection Variables { get; }
+
+ IReadOnlyList Whitespaces { get; }
+
+ IDictionary Flags { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IGlobalRunSpec.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IGlobalRunSpec.cs
new file mode 100644
index 000000000000..95b540f93ccb
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IGlobalRunSpec.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IGlobalRunSpec
+ {
+ IReadOnlyList Exclude { get; }
+
+ IReadOnlyList Include { get; }
+
+ IReadOnlyList CopyOnly { get; }
+
+ IReadOnlyList Operations { get; }
+
+ IVariableCollection RootVariableCollection { get; }
+
+ IReadOnlyList> Special { get; }
+
+ IReadOnlyList IgnoreFileNames { get; }
+
+ bool TryGetTargetRelPath(string sourceRelPath, out string targetRelPath);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IKeysChangedEventArgs.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IKeysChangedEventArgs.cs
new file mode 100644
index 000000000000..e20b8fe01275
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IKeysChangedEventArgs.cs
@@ -0,0 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IKeysChangedEventArgs;
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOperation.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOperation.cs
new file mode 100644
index 000000000000..6adc734025b7
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOperation.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IOperation
+ {
+ IReadOnlyList Tokens { get; }
+
+ string? Id { get; }
+
+ bool IsInitialStateOn { get; }
+
+ int HandleMatch(IProcessorState processor, int bufferLength, ref int currentBufferPosition, int token);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOperationProvider.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOperationProvider.cs
new file mode 100644
index 000000000000..4aa078121acc
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOperationProvider.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IOperationProvider
+ {
+ string? Id { get; }
+
+ IOperation GetOperation(Encoding encoding, IProcessorState processorState);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOrchestrator.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOrchestrator.cs
new file mode 100644
index 000000000000..cc83c43e5bc9
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IOrchestrator.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions;
+using Microsoft.TemplateEngine.Abstractions.Mount;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IOrchestrator
+ {
+ void Run(string runSpecPath, IDirectory sourceDir, string targetDir);
+
+ void Run(IGlobalRunSpec spec, IDirectory sourceDir, string targetDir);
+
+ IReadOnlyList GetFileChanges(string runSpecPath, IDirectory sourceDir, string targetDir);
+
+ IReadOnlyList GetFileChanges(IGlobalRunSpec spec, IDirectory sourceDir, string targetDir);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IPathMatcher.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IPathMatcher.cs
new file mode 100644
index 000000000000..a12a49d61d4b
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IPathMatcher.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IPathMatcher
+ {
+ string Pattern { get; }
+
+ bool IsMatch(string path);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IProcessor.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IProcessor.cs
new file mode 100644
index 000000000000..d565902f21b5
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IProcessor.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IProcessor
+ {
+ bool Run(Stream source, Stream target);
+
+ bool Run(Stream source, Stream target, int bufferSize);
+
+ bool Run(Stream source, Stream target, int bufferSize, int flushThreshold);
+
+ IProcessor CloneAndAppendOperations(IReadOnlyList tempOperations);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IProcessorState.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IProcessorState.cs
new file mode 100644
index 000000000000..7dbfeec82a58
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IProcessorState.cs
@@ -0,0 +1,77 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IProcessorState
+ {
+ IEngineConfig Config { get; }
+
+ ///
+ /// Gets the buffer containing the chunk of source stream that is being processed.
+ ///
+ byte[] CurrentBuffer { get; }
+
+ ///
+ /// Gets the length of useful data in .
+ ///
+ int CurrentBufferLength { get; }
+
+ ///
+ /// Gets the current position in .
+ ///
+ int CurrentBufferPosition { get; }
+
+ ///
+ /// Gets the current position in source stream.
+ ///
+ int CurrentSequenceNumber { get; }
+
+ IEncodingConfig EncodingConfig { get; }
+
+ Encoding Encoding { get; }
+
+ ///
+ /// Advances source stream to position .
+ ///
+ bool AdvanceBuffer(int bufferPosition);
+
+ ///
+ /// Seeks source stream until is found.
+ ///
+ /// The token to find.
+ /// The length of the buffer after the token is found.
+ /// The position in the buffer after the token is found.
+ /// True if token should be sought through.
+ void SeekSourceForwardUntil(ITokenTrie match, ref int bufferLength, ref int currentBufferPosition, bool consumeToken = false);
+
+ ///
+ /// Seeks source stream while is found.
+ ///
+ void SeekSourceForwardWhile(ITokenTrie match, ref int bufferLength, ref int currentBufferPosition);
+
+ ///
+ /// Seeks target stream backwards until is found.
+ ///
+ /// The token to find.
+ /// True if token should be sought through.
+ void SeekTargetBackUntil(ITokenTrie match, bool consumeToken = false);
+
+ ///
+ /// Seeks target stream backwards while is found.
+ ///
+ void SeekTargetBackWhile(ITokenTrie match);
+
+ ///
+ /// Writes to target stream.
+ ///
+ /// The buffer to write.
+ /// The start position in the buffer to write.
+ /// The count of bytes to write.
+ void WriteToTarget(byte[] buffer, int offset, int count);
+
+ void Inject(Stream staged);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IReplacementTokens.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IReplacementTokens.cs
new file mode 100644
index 000000000000..007f8c8a7400
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IReplacementTokens.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IReplacementTokens
+ {
+ string VariableName { get; }
+
+ ITokenConfig OriginalValue { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IRunSpec.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IRunSpec.cs
new file mode 100644
index 000000000000..ab6f95b2813f
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IRunSpec.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IRunSpec
+ {
+ string VariableFormatString { get; }
+
+ bool TryGetTargetRelPath(string sourceRelPath, out string? targetRelPath);
+
+ IReadOnlyList GetOperations(IReadOnlyList sourceOperations);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IToken.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IToken.cs
new file mode 100644
index 000000000000..4f88795c9cd3
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IToken.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IToken
+ {
+ ///
+ /// The value to match.
+ ///
+ byte[] Value { get; }
+
+ ///
+ /// Start of actual token. May be not 0, when look arounds are used.
+ ///
+ int Start { get; }
+
+ ///
+ /// Start of actual token. May be not Value.Length, when look arounds are used.
+ ///
+ int End { get; }
+
+ ///
+ /// The length of the actual token.
+ ///
+ int Length { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenConfig.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenConfig.cs
new file mode 100644
index 000000000000..3d545a522117
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenConfig.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface ITokenConfig : IEquatable
+ {
+ string? After { get; }
+
+ string? Before { get; }
+
+ string? Value { get; }
+
+ IToken ToToken(Encoding encoding);
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenTrie.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenTrie.cs
new file mode 100644
index 000000000000..76917ce1d325
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenTrie.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface ITokenTrie
+ {
+ int Count { get; }
+
+ int MaxLength { get; }
+
+ int MinLength { get; }
+
+ IReadOnlyList TokenLength { get; }
+
+ IReadOnlyList Tokens { get; }
+
+ int AddToken(IToken token);
+
+ void AddToken(IToken? token, int index);
+
+ bool GetOperation(byte[] buffer, int bufferLength, ref int currentBufferPosition, out int token);
+
+ bool GetOperation(byte[] buffer, int bufferLength, ref int currentBufferPosition, bool mustMatchPosition, out int token);
+
+ void Append(ITokenTrie trie);
+
+ ITokenTrieEvaluator CreateEvaluator();
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenTrieEvaluator.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenTrieEvaluator.cs
new file mode 100644
index 000000000000..543c90264fca
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ITokenTrieEvaluator.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface ITokenTrieEvaluator
+ {
+ int BytesToKeepInBuffer { get; }
+
+ bool Accept(byte data, ref int bufferPosition, out int token);
+
+ bool TryFinalizeMatchesInProgress(ref int bufferPosition, out int token);
+ }
+}
\ No newline at end of file
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IValueReadEventArgs.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IValueReadEventArgs.cs
new file mode 100644
index 000000000000..da5b4b80d7df
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IValueReadEventArgs.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IValueReadEventArgs
+ {
+ string Key { get; }
+
+ object Value { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IVariableCollection.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IVariableCollection.cs
new file mode 100644
index 000000000000..c5659944bce6
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IVariableCollection.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Abstractions;
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ ///
+ /// Extends with the events raised when collection is being read or changed.
+ ///
+ public interface IMonitoredVariableCollection : IVariableCollection
+ {
+ event KeysChangedEventHander KeysChanged;
+
+ event ValueReadEventHander ValueRead;
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IVariableConfig.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IVariableConfig.cs
new file mode 100644
index 000000000000..426c96a3c76d
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/IVariableConfig.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public interface IVariableConfig
+ {
+ IReadOnlyDictionary Sources { get; }
+
+ IReadOnlyList Order { get; }
+
+ string? FallbackFormat { get; }
+
+ bool Expand { get; }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/KeysChangedEventHander.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/KeysChangedEventHander.cs
new file mode 100644
index 000000000000..66637244b12c
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/KeysChangedEventHander.cs
@@ -0,0 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public delegate void KeysChangedEventHander(object sender, IKeysChangedEventArgs args);
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/Microsoft.TemplateEngine.Core.Contracts.csproj b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/Microsoft.TemplateEngine.Core.Contracts.csproj
new file mode 100644
index 000000000000..b63552193378
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/Microsoft.TemplateEngine.Core.Contracts.csproj
@@ -0,0 +1,19 @@
+
+
+
+ $(NetMinimum);$(NetCurrent);netstandard2.0;$(NetFrameworkMinimum)
+ Contracts for extending Microsoft.TemplateEngine.Core
+ true
+ true
+
+ true
+
+
+
+
+
+
+
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/PublicAPI.Shipped.txt b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/PublicAPI.Shipped.txt
new file mode 100644
index 000000000000..ad54f300c420
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/PublicAPI.Shipped.txt
@@ -0,0 +1,95 @@
+#nullable enable
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec
+Microsoft.TemplateEngine.Core.Contracts.IKeysChangedEventArgs
+Microsoft.TemplateEngine.Core.Contracts.IOperation
+Microsoft.TemplateEngine.Core.Contracts.IOperation.IsInitialStateOn.get -> bool
+Microsoft.TemplateEngine.Core.Contracts.IOperationProvider
+Microsoft.TemplateEngine.Core.Contracts.IOrchestrator
+Microsoft.TemplateEngine.Core.Contracts.IPathMatcher
+Microsoft.TemplateEngine.Core.Contracts.IProcessor
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.AdvanceBuffer(int bufferPosition) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.CurrentBufferLength.get -> int
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.CurrentBufferPosition.get -> int
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.CurrentSequenceNumber.get -> int
+Microsoft.TemplateEngine.Core.Contracts.IReplacementTokens
+Microsoft.TemplateEngine.Core.Contracts.IRunSpec
+Microsoft.TemplateEngine.Core.Contracts.IToken
+Microsoft.TemplateEngine.Core.Contracts.IToken.End.get -> int
+Microsoft.TemplateEngine.Core.Contracts.IToken.Length.get -> int
+Microsoft.TemplateEngine.Core.Contracts.IToken.Start.get -> int
+Microsoft.TemplateEngine.Core.Contracts.ITokenConfig
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.Count.get -> int
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.MaxLength.get -> int
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.MinLength.get -> int
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrieEvaluator
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrieEvaluator.Accept(byte data, ref int bufferPosition, out int token) -> bool
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrieEvaluator.BytesToKeepInBuffer.get -> int
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrieEvaluator.TryFinalizeMatchesInProgress(ref int bufferPosition, out int token) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IValueReadEventArgs
+Microsoft.TemplateEngine.Core.Contracts.IVariableConfig
+Microsoft.TemplateEngine.Core.Contracts.IVariableConfig.Expand.get -> bool
+Microsoft.TemplateEngine.Core.Contracts.KeysChangedEventHander
+Microsoft.TemplateEngine.Core.Contracts.ValueReadEventHander
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.Encoding.get -> System.Text.Encoding!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.LineEndings.get -> Microsoft.TemplateEngine.Core.Contracts.ITokenTrie!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.this[int index].get -> object!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.VariableKeys.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.Variables.get -> Microsoft.TemplateEngine.Core.Contracts.ITokenTrie!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.VariableValues.get -> System.Collections.Generic.IReadOnlyList!>!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.Whitespace.get -> Microsoft.TemplateEngine.Core.Contracts.ITokenTrie!
+Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig.WhitespaceOrLineEnding.get -> Microsoft.TemplateEngine.Core.Contracts.ITokenTrie!
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig.Flags.get -> System.Collections.Generic.IDictionary!
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig.LineEndings.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig.Logger.get -> Microsoft.Extensions.Logging.ILogger!
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig.VariableFormatString.get -> string!
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig.Whitespaces.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.CopyOnly.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.Exclude.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.IgnoreFileNames.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.Include.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.Operations.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.Special.get -> System.Collections.Generic.IReadOnlyList>!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.TryGetTargetRelPath(string! sourceRelPath, out string! targetRelPath) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IOperation.HandleMatch(Microsoft.TemplateEngine.Core.Contracts.IProcessorState! processor, int bufferLength, ref int currentBufferPosition, int token) -> int
+Microsoft.TemplateEngine.Core.Contracts.IOperationProvider.GetOperation(System.Text.Encoding! encoding, Microsoft.TemplateEngine.Core.Contracts.IProcessorState! processorState) -> Microsoft.TemplateEngine.Core.Contracts.IOperation!
+Microsoft.TemplateEngine.Core.Contracts.IOrchestrator.GetFileChanges(Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec! spec, Microsoft.TemplateEngine.Abstractions.Mount.IDirectory! sourceDir, string! targetDir) -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IOrchestrator.GetFileChanges(string! runSpecPath, Microsoft.TemplateEngine.Abstractions.Mount.IDirectory! sourceDir, string! targetDir) -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IOrchestrator.Run(Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec! spec, Microsoft.TemplateEngine.Abstractions.Mount.IDirectory! sourceDir, string! targetDir) -> void
+Microsoft.TemplateEngine.Core.Contracts.IOrchestrator.Run(string! runSpecPath, Microsoft.TemplateEngine.Abstractions.Mount.IDirectory! sourceDir, string! targetDir) -> void
+Microsoft.TemplateEngine.Core.Contracts.IPathMatcher.IsMatch(string! path) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IPathMatcher.Pattern.get -> string!
+Microsoft.TemplateEngine.Core.Contracts.IProcessor.CloneAndAppendOperations(System.Collections.Generic.IReadOnlyList! tempOperations) -> Microsoft.TemplateEngine.Core.Contracts.IProcessor!
+Microsoft.TemplateEngine.Core.Contracts.IProcessor.Run(System.IO.Stream! source, System.IO.Stream! target) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IProcessor.Run(System.IO.Stream! source, System.IO.Stream! target, int bufferSize) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IProcessor.Run(System.IO.Stream! source, System.IO.Stream! target, int bufferSize, int flushThreshold) -> bool
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.Config.get -> Microsoft.TemplateEngine.Core.Contracts.IEngineConfig!
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.CurrentBuffer.get -> byte[]!
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.Encoding.get -> System.Text.Encoding!
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.EncodingConfig.get -> Microsoft.TemplateEngine.Core.Contracts.IEncodingConfig!
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.Inject(System.IO.Stream! staged) -> void
+Microsoft.TemplateEngine.Core.Contracts.IReplacementTokens.OriginalValue.get -> Microsoft.TemplateEngine.Core.Contracts.ITokenConfig!
+Microsoft.TemplateEngine.Core.Contracts.IReplacementTokens.VariableName.get -> string!
+Microsoft.TemplateEngine.Core.Contracts.IRunSpec.GetOperations(System.Collections.Generic.IReadOnlyList! sourceOperations) -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IRunSpec.VariableFormatString.get -> string!
+Microsoft.TemplateEngine.Core.Contracts.IToken.Value.get -> byte[]!
+Microsoft.TemplateEngine.Core.Contracts.ITokenConfig.After.get -> string?
+Microsoft.TemplateEngine.Core.Contracts.ITokenConfig.Before.get -> string?
+Microsoft.TemplateEngine.Core.Contracts.ITokenConfig.ToToken(System.Text.Encoding! encoding) -> Microsoft.TemplateEngine.Core.Contracts.IToken!
+Microsoft.TemplateEngine.Core.Contracts.ITokenConfig.Value.get -> string?
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.AddToken(Microsoft.TemplateEngine.Core.Contracts.IToken! token) -> int
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.Append(Microsoft.TemplateEngine.Core.Contracts.ITokenTrie! trie) -> void
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.CreateEvaluator() -> Microsoft.TemplateEngine.Core.Contracts.ITokenTrieEvaluator!
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.GetOperation(byte[]! buffer, int bufferLength, ref int currentBufferPosition, bool mustMatchPosition, out int token) -> bool
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.GetOperation(byte[]! buffer, int bufferLength, ref int currentBufferPosition, out int token) -> bool
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.TokenLength.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.Tokens.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IValueReadEventArgs.Key.get -> string!
+Microsoft.TemplateEngine.Core.Contracts.IValueReadEventArgs.Value.get -> object!
+Microsoft.TemplateEngine.Core.Contracts.IVariableConfig.FallbackFormat.get -> string?
+Microsoft.TemplateEngine.Core.Contracts.IVariableConfig.Order.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IVariableConfig.Sources.get -> System.Collections.Generic.IReadOnlyDictionary!
+
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/PublicAPI.Unshipped.txt b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000000..250a1f58eab3
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/PublicAPI.Unshipped.txt
@@ -0,0 +1,15 @@
+Microsoft.TemplateEngine.Core.Contracts.IEngineConfig.Variables.get -> Microsoft.TemplateEngine.Abstractions.IVariableCollection!
+Microsoft.TemplateEngine.Core.Contracts.IGlobalRunSpec.RootVariableCollection.get -> Microsoft.TemplateEngine.Abstractions.IVariableCollection!
+Microsoft.TemplateEngine.Core.Contracts.IMonitoredVariableCollection
+Microsoft.TemplateEngine.Core.Contracts.IMonitoredVariableCollection.KeysChanged -> Microsoft.TemplateEngine.Core.Contracts.KeysChangedEventHander!
+Microsoft.TemplateEngine.Core.Contracts.IMonitoredVariableCollection.ValueRead -> Microsoft.TemplateEngine.Core.Contracts.ValueReadEventHander!
+Microsoft.TemplateEngine.Core.Contracts.IOperation.Id.get -> string?
+Microsoft.TemplateEngine.Core.Contracts.IOperation.Tokens.get -> System.Collections.Generic.IReadOnlyList!
+Microsoft.TemplateEngine.Core.Contracts.IOperationProvider.Id.get -> string?
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.SeekSourceForwardUntil(Microsoft.TemplateEngine.Core.Contracts.ITokenTrie! match, ref int bufferLength, ref int currentBufferPosition, bool consumeToken = false) -> void
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.SeekSourceForwardWhile(Microsoft.TemplateEngine.Core.Contracts.ITokenTrie! match, ref int bufferLength, ref int currentBufferPosition) -> void
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.SeekTargetBackUntil(Microsoft.TemplateEngine.Core.Contracts.ITokenTrie! match, bool consumeToken = false) -> void
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.SeekTargetBackWhile(Microsoft.TemplateEngine.Core.Contracts.ITokenTrie! match) -> void
+Microsoft.TemplateEngine.Core.Contracts.IProcessorState.WriteToTarget(byte[]! buffer, int offset, int count) -> void
+Microsoft.TemplateEngine.Core.Contracts.IRunSpec.TryGetTargetRelPath(string! sourceRelPath, out string? targetRelPath) -> bool
+Microsoft.TemplateEngine.Core.Contracts.ITokenTrie.AddToken(Microsoft.TemplateEngine.Core.Contracts.IToken? token, int index) -> void
\ No newline at end of file
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ValueReadEventHander.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ValueReadEventHander.cs
new file mode 100644
index 000000000000..2a2880b8c129
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core.Contracts/ValueReadEventHander.cs
@@ -0,0 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Contracts
+{
+ public delegate void ValueReadEventHander(object sender, IValueReadEventArgs args);
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/CommonOperations.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/CommonOperations.cs
new file mode 100644
index 000000000000..157d0e13ac6b
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/CommonOperations.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Core.Contracts;
+
+namespace Microsoft.TemplateEngine.Core
+{
+ public static class CommonOperations
+ {
+ public static void WhitespaceHandler(this IProcessorState processor, ref int bufferLength, ref int currentBufferPosition, bool wholeLine = false, bool trim = false, bool trimForward = false, bool trimBackward = false)
+ {
+ if (wholeLine)
+ {
+ processor.ConsumeWholeLine(ref bufferLength, ref currentBufferPosition);
+ return;
+ }
+
+ if (trim)
+ {
+ trimForward = true;
+ trimBackward = true;
+ }
+
+ processor.TrimWhitespace(trimForward, trimBackward, ref bufferLength, ref currentBufferPosition);
+ }
+
+ public static void ConsumeWholeLine(this IProcessorState processor, ref int bufferLength, ref int currentBufferPosition)
+ {
+ processor.SeekTargetBackWhile(processor.EncodingConfig.Whitespace);
+ processor.SeekSourceForwardUntil(processor.EncodingConfig.LineEndings, ref bufferLength, ref currentBufferPosition, consumeToken: true);
+ }
+
+ public static void TrimWhitespace(this IProcessorState processor, bool forward, bool backward, ref int bufferLength, ref int currentBufferPosition)
+ {
+ if (backward)
+ {
+ processor.SeekTargetBackWhile(processor.EncodingConfig.Whitespace);
+ }
+
+ if (forward)
+ {
+ processor.SeekSourceForwardWhile(processor.EncodingConfig.Whitespace, ref bufferLength, ref currentBufferPosition);
+ //Consume the trailing line end if possible
+ _ = processor.EncodingConfig.LineEndings.GetOperation(processor.CurrentBuffer, bufferLength, ref currentBufferPosition, out _);
+ }
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/BinaryScope.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/BinaryScope.cs
new file mode 100644
index 000000000000..41337b341fca
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/BinaryScope.cs
@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Expressions
+{
+ public class BinaryScope : IEvaluable
+ {
+ private readonly Func _evaluate;
+
+ public BinaryScope(IEvaluable? parent, TOperator @operator, Func evaluate)
+ {
+ Parent = parent;
+ Operator = @operator;
+ _evaluate = evaluate;
+ }
+
+ public bool IsFull => Left != null && Right != null;
+
+ public bool IsIndivisible => false;
+
+ public IEvaluable? Left { get; set; }
+
+ public TOperator Operator { get; }
+
+ public IEvaluable? Parent { get; set; }
+
+ public IEvaluable? Right { get; set; }
+
+ public object Evaluate()
+ {
+ object? left = Left?.Evaluate();
+ object? right = Right?.Evaluate();
+ return _evaluate(left, right);
+ }
+
+ public override string ToString()
+ {
+ return $@"({Left} -{Operator}- {Right})";
+ }
+
+ public bool TryAccept(IEvaluable? child)
+ {
+ if (Left == null)
+ {
+ Left = child;
+ return true;
+ }
+
+ if (Right == null)
+ {
+ Right = child;
+ return true;
+ }
+
+ return false;
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Converter.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Converter.cs
new file mode 100644
index 000000000000..0c678aa773bb
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Converter.cs
@@ -0,0 +1,163 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Utils;
+
+namespace Microsoft.TemplateEngine.Core.Expressions
+{
+ public static class Converter
+ {
+ static Converter()
+ {
+ Register(new BoolConverter());
+ Register(new IntConverter());
+ Register(new LongConverter());
+ Register(new FloatConverter());
+ Register(new DoubleConverter());
+ Register(new StringConverter());
+ }
+
+ public static bool TryConvert(object? source, out T? result)
+ {
+ return ConverterItem.TryExecute(source, out result);
+ }
+
+ private static void Register(ConverterItem item)
+ {
+ ConverterItem.IsHandledBy(item);
+ }
+
+ private abstract class ConverterItem
+ {
+ public static ConverterItem? Instance { get; private set; }
+
+ public static void IsHandledBy(TInstance instance)
+ where TInstance : ConverterItem
+ {
+ Instance = instance;
+ }
+
+ public static bool TryExecute(object? source, out T? result)
+ {
+ if (source is T x)
+ {
+ result = x;
+ return true;
+ }
+
+ T? handlerValue = default;
+ bool? handlerResult = Instance?.TryExecuteInternal(source, out handlerValue);
+
+ if (handlerResult.HasValue)
+ {
+ result = handlerValue;
+ return handlerResult.Value;
+ }
+
+ if (typeof(T).IsEnum && source is string s)
+ {
+ try
+ {
+ result = (T)Enum.Parse(typeof(T), s, true);
+ return true;
+ }
+ catch
+ {
+ }
+ }
+
+ try
+ {
+ result = (T)Convert.ChangeType(source, typeof(T));
+ return true;
+ }
+ catch
+ {
+ result = default;
+ return false;
+ }
+ }
+
+ protected abstract bool? TryExecuteInternal(object? source, out T? result);
+ }
+
+ private class BoolConverter : ConverterItem
+ {
+ protected override bool? TryExecuteInternal(object? source, out bool result)
+ {
+ if (source is string s)
+ {
+ return bool.TryParse(s, out result);
+ }
+
+ result = false;
+ return null;
+ }
+ }
+
+ private class IntConverter : ConverterItem
+ {
+ protected override bool? TryExecuteInternal(object? source, out int result)
+ {
+ if (source is string s)
+ {
+ return int.TryParse(s, out result);
+ }
+
+ result = 0;
+ return null;
+ }
+ }
+
+ private class LongConverter : ConverterItem
+ {
+ protected override bool? TryExecuteInternal(object? source, out long result)
+ {
+ if (source is string s)
+ {
+ return long.TryParse(s, out result);
+ }
+
+ result = 0;
+ return null;
+ }
+ }
+
+ private class FloatConverter : ConverterItem
+ {
+ protected override bool? TryExecuteInternal(object? source, out float result)
+ {
+ if (source is string s)
+ {
+ return float.TryParse(s, out result);
+ }
+
+ result = 0;
+ return null;
+ }
+ }
+
+ private class DoubleConverter : ConverterItem
+ {
+ protected override bool? TryExecuteInternal(object? source, out double result)
+ {
+ if (source is string s)
+ {
+ return ParserExtensions.DoubleTryParseCurrentOrInvariant(s, out result);
+ }
+
+ result = 0;
+ return null;
+ }
+ }
+
+ private class StringConverter : ConverterItem
+ {
+ protected override bool? TryExecuteInternal(object? source, out string? result)
+ {
+ result = source?.ToString();
+ return true;
+ }
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/CppStyleEvaluatorDefinition.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/CppStyleEvaluatorDefinition.cs
new file mode 100644
index 000000000000..efc8d17dfec4
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/CppStyleEvaluatorDefinition.cs
@@ -0,0 +1,580 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+using Microsoft.Extensions.Logging;
+using Microsoft.TemplateEngine.Abstractions;
+using Microsoft.TemplateEngine.Core.Contracts;
+using Microsoft.TemplateEngine.Core.Util;
+using Microsoft.TemplateEngine.Utils;
+
+namespace Microsoft.TemplateEngine.Core.Expressions.Cpp
+{
+ public static class CppStyleEvaluatorDefinition
+ {
+ private const int ReservedTokenCount = 24;
+ private const int ReservedTokenMaxIndex = ReservedTokenCount - 1;
+ private static readonly IOperationProvider[] NoOperationProviders = [];
+ private static readonly char[] SupportedQuotes = { '"', '\'' };
+
+ public static bool EvaluateFromString(ILogger logger, string text, IVariableCollection variables)
+ {
+ using MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(text));
+ using MemoryStream res = new MemoryStream();
+ EngineConfig cfg = new EngineConfig(logger, variables);
+ IProcessorState state = new ProcessorState(ms, res, (int)ms.Length, (int)ms.Length, cfg, NoOperationProviders);
+ int len = (int)ms.Length;
+ int pos = 0;
+ return Evaluate(state, ref len, ref pos, out bool faulted);
+ }
+
+ public static bool Evaluate(IProcessorState processor, ref int bufferLength, ref int currentBufferPosition, out bool faulted)
+ {
+ faulted = false;
+ TokenTrie trie = new TokenTrie();
+
+ //Logic
+ trie.AddToken(processor.Encoding.GetBytes("&&"), 0);
+ trie.AddToken(processor.Encoding.GetBytes("||"), 1);
+ trie.AddToken(processor.Encoding.GetBytes("^"), 2);
+ trie.AddToken(processor.Encoding.GetBytes("!"), 3);
+ trie.AddToken(processor.Encoding.GetBytes(">"), 4);
+ trie.AddToken(processor.Encoding.GetBytes(">="), 5);
+ trie.AddToken(processor.Encoding.GetBytes("<"), 6);
+ trie.AddToken(processor.Encoding.GetBytes("<="), 7);
+ trie.AddToken(processor.Encoding.GetBytes("=="), 8);
+ trie.AddToken(processor.Encoding.GetBytes("="), 9);
+ trie.AddToken(processor.Encoding.GetBytes("!="), 10);
+
+ //Bitwise
+ trie.AddToken(processor.Encoding.GetBytes("&"), 11);
+ trie.AddToken(processor.Encoding.GetBytes("|"), 12);
+ trie.AddToken(processor.Encoding.GetBytes("<<"), 13);
+ trie.AddToken(processor.Encoding.GetBytes(">>"), 14);
+
+ //Braces
+ trie.AddToken(processor.Encoding.GetBytes("("), 15);
+ trie.AddToken(processor.Encoding.GetBytes(")"), 16);
+
+ //Whitespace
+ trie.AddToken(processor.Encoding.GetBytes(" "), 17);
+ trie.AddToken(processor.Encoding.GetBytes("\t"), 18);
+
+ //EOLs
+ trie.AddToken(processor.Encoding.GetBytes("\r\n"), 19);
+ trie.AddToken(processor.Encoding.GetBytes("\n"), 20);
+ trie.AddToken(processor.Encoding.GetBytes("\r"), 21);
+
+ // quotes
+ trie.AddToken(processor.Encoding.GetBytes("\""), 22);
+ trie.AddToken(processor.Encoding.GetBytes("'"), 23);
+
+ //Tokens
+ trie.Append(processor.EncodingConfig.Variables);
+
+ //Run forward to EOL and collect args
+ TokenFamily currentTokenFamily;
+ List currentTokenBytes = new List();
+ List tokens = new List();
+ if (!trie.GetOperation(processor.CurrentBuffer, bufferLength, ref currentBufferPosition, out int token))
+ {
+ currentTokenFamily = TokenFamily.Literal;
+ currentTokenBytes.Add(processor.CurrentBuffer[currentBufferPosition++]);
+ }
+ else if (token > ReservedTokenMaxIndex)
+ {
+ currentTokenFamily = TokenFamily.Reference | (TokenFamily)token;
+ tokens.Add(new TokenRef
+ {
+ Family = currentTokenFamily
+ });
+ }
+ else
+ {
+ currentTokenFamily = (TokenFamily)token;
+
+ if (currentTokenFamily is not TokenFamily.WindowsEOL and not TokenFamily.LegacyMacEOL and not TokenFamily.UnixEOL)
+ {
+ tokens.Add(new TokenRef
+ {
+ Family = currentTokenFamily
+ });
+ }
+ else
+ {
+ return EvaluateCondition(tokens, processor.EncodingConfig.VariableValues);
+ }
+ }
+
+ int braceDepth = 0;
+ if (tokens.Count > 0 && tokens[0].Family == TokenFamily.OpenBrace)
+ {
+ ++braceDepth;
+ }
+
+ bool first = true;
+ QuotedRegionKind inQuoteType = QuotedRegionKind.None;
+
+ while ((first || braceDepth > 0) && bufferLength > 0)
+ {
+ int targetLen = Math.Min(bufferLength, trie.MaxLength);
+ for (; currentBufferPosition < bufferLength - targetLen + 1;)
+ {
+ int oldBufferPos = currentBufferPosition;
+ if (trie.GetOperation(processor.CurrentBuffer, bufferLength, ref currentBufferPosition, out token))
+ {
+ if (braceDepth == 0)
+ {
+ switch (tokens[tokens.Count - 1].Family)
+ {
+ case TokenFamily.Whitespace:
+ case TokenFamily.Tab:
+ case TokenFamily.CloseBrace:
+ case TokenFamily.WindowsEOL:
+ case TokenFamily.UnixEOL:
+ case TokenFamily.LegacyMacEOL:
+ TokenFamily thisFamily = (TokenFamily)token;
+ if (thisFamily is TokenFamily.WindowsEOL or TokenFamily.UnixEOL or TokenFamily.LegacyMacEOL)
+ {
+ currentBufferPosition = oldBufferPos;
+ }
+
+ break;
+ default:
+ currentBufferPosition = oldBufferPos;
+ first = false;
+ break;
+ }
+
+ if (!first)
+ {
+ break;
+ }
+ }
+
+ // We matched an item, so whatever this is, it's not a literal.
+ // if the current token is a literal, end it.
+ if (currentTokenFamily == TokenFamily.Literal)
+ {
+ string literal = processor.Encoding.GetString(currentTokenBytes.ToArray());
+ tokens.Add(new TokenRef
+ {
+ Family = TokenFamily.Literal,
+ Literal = literal
+ });
+ currentTokenBytes.Clear();
+ }
+
+ TokenFamily foundTokenFamily = (TokenFamily)token;
+
+ if (foundTokenFamily is TokenFamily.QuotedLiteral or TokenFamily.SingleQuotedLiteral)
+ {
+ var incomingQuoteKind = foundTokenFamily switch
+ {
+ TokenFamily.QuotedLiteral => QuotedRegionKind.DoubleQuoteRegion,
+ TokenFamily.SingleQuotedLiteral => QuotedRegionKind.SingleQuoteRegion,
+ _ => QuotedRegionKind.None,
+ };
+ if (inQuoteType == QuotedRegionKind.None)
+ {
+ // starting quote found
+ currentTokenBytes.AddRange(trie.Tokens[token].Value);
+ inQuoteType = incomingQuoteKind;
+ }
+ else if (incomingQuoteKind == inQuoteType)
+ {
+ // end quote found
+ currentTokenBytes.AddRange(trie.Tokens[token].Value);
+ tokens.Add(new TokenRef
+ {
+ Family = TokenFamily.Literal,
+ Literal = processor.Encoding.GetString(currentTokenBytes.ToArray())
+ });
+ currentTokenBytes.Clear();
+ inQuoteType = QuotedRegionKind.None;
+ }
+ else
+ {
+ // this is a different quote type. Treat it like a non-match, just add the token to the currentTokenBytes
+ currentTokenBytes.AddRange(trie.Tokens[token].Value);
+ }
+ }
+ else if (inQuoteType != QuotedRegionKind.None)
+ {
+ // we're inside a quoted literal, the token found by the trie should not be processed, just included with the literal
+ currentTokenBytes.AddRange(trie.Tokens[token].Value);
+ }
+ else if (token > ReservedTokenMaxIndex)
+ {
+ currentTokenFamily = TokenFamily.Reference | (TokenFamily)token;
+ tokens.Add(new TokenRef
+ {
+ Family = currentTokenFamily
+ });
+ }
+ else
+ {
+ //If we have a normal token...
+ currentTokenFamily = (TokenFamily)token;
+
+ if (currentTokenFamily is not TokenFamily.WindowsEOL and not TokenFamily.LegacyMacEOL and not TokenFamily.UnixEOL)
+ {
+ switch (currentTokenFamily)
+ {
+ case TokenFamily.OpenBrace:
+ ++braceDepth;
+ break;
+ case TokenFamily.CloseBrace:
+ --braceDepth;
+ break;
+ }
+
+ tokens.Add(new TokenRef
+ {
+ Family = currentTokenFamily
+ });
+ }
+ else
+ {
+ return EvaluateCondition(tokens, processor.EncodingConfig.VariableValues);
+ }
+ }
+ }
+ else if (inQuoteType != QuotedRegionKind.None)
+ {
+ // we're in a quoted literal but did not match a token at the current position.
+ // so just add the current byte to the currentTokenBytes
+ currentTokenBytes.Add(processor.CurrentBuffer[currentBufferPosition++]);
+ }
+ else if (braceDepth > 0)
+ {
+ currentTokenFamily = TokenFamily.Literal;
+ currentTokenBytes.Add(processor.CurrentBuffer[currentBufferPosition++]);
+ }
+ else
+ {
+ first = false;
+ break;
+ }
+ }
+
+ processor.AdvanceBuffer(currentBufferPosition);
+ currentBufferPosition = processor.CurrentBufferPosition;
+ bufferLength = processor.CurrentBufferLength;
+ }
+
+#if DEBUG
+ Debug.Assert(
+ inQuoteType == QuotedRegionKind.None,
+ $"Malformed predicate due to unmatched quotes. InitialBuffer = {processor.Encoding.GetString(processor.CurrentBuffer)} currentTokenFamily = {currentTokenFamily} | TokenFamily.QuotedLiteral = {TokenFamily.QuotedLiteral} | TokenFamily.SingleQuotedLiteral = {TokenFamily.SingleQuotedLiteral}");
+#endif
+
+ return EvaluateCondition(tokens, processor.EncodingConfig.VariableValues);
+ }
+
+ private static bool IsLogicalOperator(Operator op)
+ {
+ return op is Operator.And or Operator.Or or Operator.Xor or Operator.Not;
+ }
+
+ private static void CombineExpressionOperator(ref Scope current, Stack parents)
+ {
+ if (current.Operator == Operator.None)
+ {
+ if (current.TargetPlacement != Scope.NextPlacement.Right
+ || current.Left is not Scope leftScope
+ || !IsLogicalOperator(leftScope.Operator))
+ {
+ return;
+ }
+
+ Scope tmp2 = new Scope
+ {
+ Value = leftScope.Right!
+ };
+
+ leftScope.Right = tmp2;
+ parents.Push(leftScope);
+ current = tmp2;
+ return;
+ }
+
+ Scope tmp = new Scope();
+
+ if (!IsLogicalOperator(current.Operator))
+ {
+ tmp.Value = current;
+ }
+ else
+ {
+ tmp.Value = current.Right!;
+ current.Right = tmp;
+ parents.Push(current);
+ }
+
+ current = tmp;
+ }
+
+ private static bool EvaluateCondition(IReadOnlyList tokens, IReadOnlyList> values)
+ {
+ //Skip over all leading whitespace
+ int i = 0;
+ for (; i < tokens.Count && (tokens[i].Family == TokenFamily.Whitespace || tokens[i].Family == TokenFamily.Tab); ++i)
+ {
+ }
+
+ //Scan through all remaining tokens and put them in a form the standard evaluator can understand
+ List outputTokens = new List();
+ for (; i < tokens.Count; ++i)
+ {
+ if (tokens[i].Family is TokenFamily.Whitespace or TokenFamily.Tab)
+ {
+ //Ignore whitespace
+ }
+ else
+ {
+ if (tokens[i].Family.HasFlag(TokenFamily.Reference))
+ {
+ outputTokens.Add(tokens[i]);
+ }
+ else if (tokens[i].Family == TokenFamily.Literal)
+ {
+ //Combine literals
+ string literalValue = tokens[i].Literal!;
+ string followingWhitespace = string.Empty;
+ int reach = i;
+
+ for (int j = i + 1; j < tokens.Count; ++j)
+ {
+ switch (tokens[j].Family)
+ {
+ case TokenFamily.Literal:
+ literalValue += followingWhitespace + tokens[j].Literal;
+ followingWhitespace = string.Empty;
+ reach = j;
+ break;
+ case TokenFamily.Tab:
+ followingWhitespace += '\t';
+ break;
+ case TokenFamily.Whitespace:
+ followingWhitespace += ' ';
+ break;
+ default:
+ j = tokens.Count;
+ break;
+ }
+ }
+
+ i = reach;
+ outputTokens.Add(new TokenRef
+ {
+ Family = TokenFamily.Literal,
+ Literal = literalValue
+ });
+ }
+ else
+ {
+ outputTokens.Add(tokens[i]);
+ }
+ }
+ }
+
+ Scope root = new Scope();
+ Scope current = root;
+ Stack parents = new Stack();
+
+ for (i = 0; i < outputTokens.Count; ++i)
+ {
+ switch (outputTokens[i].Family)
+ {
+ case TokenFamily.Not:
+ {
+ Scope nextScope = new Scope
+ {
+ TargetPlacement = Scope.NextPlacement.Right
+ };
+
+ current.Value = nextScope;
+ parents.Push(current);
+ current = nextScope;
+ current.Operator = Operator.Not;
+ break;
+ }
+ case TokenFamily.Literal:
+ current.Value = InferTypeAndConvertLiteral(outputTokens[i].Literal!)!;
+
+ while (parents.Count > 0 && current.TargetPlacement == Scope.NextPlacement.None)
+ {
+ current = parents.Pop();
+ }
+ break;
+ case TokenFamily.And:
+ if (current.Operator != Operator.None)
+ {
+ Scope s = new Scope
+ {
+ Value = current
+ };
+
+ current = s;
+ }
+
+ current.Operator = Operator.And;
+ current.TargetPlacement = Scope.NextPlacement.Right;
+ break;
+ case TokenFamily.BitwiseAnd:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.BitwiseAnd;
+ break;
+ case TokenFamily.BitwiseOr:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.BitwiseOr;
+ break;
+ case TokenFamily.CloseBrace:
+ //If the grouping is valid, the grouping has already been closed
+ // due to argument fulfillment, do nothing.
+ // -- OR --
+ //This is a grouping around a unary operator
+ if (parents.Count > 0 && current.TargetPlacement == Scope.NextPlacement.Right)
+ {
+ current = parents.Pop();
+ }
+ break;
+ case TokenFamily.EqualTo:
+ case TokenFamily.EqualToShort:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.EqualTo;
+ break;
+ case TokenFamily.GreaterThan:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.GreaterThan;
+ break;
+ case TokenFamily.GreaterThanOrEqualTo:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.GreaterThanOrEqualTo;
+ break;
+ case TokenFamily.LeftShift:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.LeftShift;
+ break;
+ case TokenFamily.LessThan:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.LessThan;
+ break;
+ case TokenFamily.LessThanOrEqualTo:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.LessThanOrEqualTo;
+ break;
+ case TokenFamily.NotEqualTo:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.NotEqualTo;
+ break;
+ case TokenFamily.OpenBrace:
+ {
+ Scope nextScope = new Scope();
+ current.Value = nextScope;
+ parents.Push(current);
+ current = nextScope;
+ break;
+ }
+ case TokenFamily.Or:
+ if (current.Operator != Operator.None)
+ {
+ Scope s = new Scope
+ {
+ Value = current
+ };
+
+ current = s;
+ }
+
+ current.Operator = Operator.Or;
+ break;
+ case TokenFamily.RightShift:
+ CombineExpressionOperator(ref current, parents);
+ current.Operator = Operator.RightShift;
+ break;
+ case TokenFamily.Xor:
+ if (current.Operator != Operator.None)
+ {
+ Scope s = new Scope
+ {
+ Value = current
+ };
+
+ current = s;
+ }
+
+ current.Operator = Operator.Xor;
+ break;
+ default:
+ current.Value = ResolveToken(outputTokens[i], values);
+
+ while (parents.Count > 0 && current.TargetPlacement == Scope.NextPlacement.None)
+ {
+ current = parents.Pop();
+ }
+
+ break;
+ }
+ }
+
+ Debug.Assert(parents.Count == 0, "Unbalanced condition");
+ return (bool)Convert.ChangeType(current.Evaluate() ?? "false", typeof(bool));
+ }
+
+ private static object? InferTypeAndConvertLiteral(string literal)
+ {
+ // A properly quoted string must be...
+ // At least two characters long
+ // Start and end with the same character
+ // The character that the string starts with must be one of the supported quote kinds
+ if (literal.Length < 2 || literal[0] != literal[literal.Length - 1] || !SupportedQuotes.Contains(literal[0]))
+ {
+ if (string.Equals(literal, "true", StringComparison.OrdinalIgnoreCase)) // CodeQL [cs/campaign/constantine] False Positive: CodeQL wrongly detected "literal"
+ {
+ return true;
+ }
+
+ if (string.Equals(literal, "false", StringComparison.OrdinalIgnoreCase)) // CodeQL [cs/campaign/constantine] False Positive: CodeQL wrongly detected "literal"
+ {
+ return false;
+ }
+
+ if (string.Equals(literal, "null", StringComparison.OrdinalIgnoreCase)) // CodeQL [cs/campaign/constantine] False Positive: CodeQL wrongly detected "literal"
+ {
+ return null;
+ }
+
+ if ((literal.Contains(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)
+ || literal.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
+ && ParserExtensions.DoubleTryParseCurrentOrInvariant(literal, out double literalDouble))
+ {
+ return literalDouble;
+ }
+
+ if (long.TryParse(literal, out long literalLong))
+ {
+ return literalLong;
+ }
+
+ if (literal.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
+ && long.TryParse(literal.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out literalLong))
+ {
+ return literalLong;
+ }
+
+ return null;
+ }
+
+ return literal.Substring(1, literal.Length - 2);
+ }
+
+ private static object ResolveToken(TokenRef tokenRef, IReadOnlyList> values)
+ {
+ return values[(int)(tokenRef.Family & ~TokenFamily.Reference) - ReservedTokenCount]();
+ }
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/Operator.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/Operator.cs
new file mode 100644
index 000000000000..3e4bf204d6cd
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/Operator.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Expressions.Cpp
+{
+ internal enum Operator
+ {
+ None,
+ And,
+ Or,
+ Xor,
+ Not,
+ GreaterThan,
+ GreaterThanOrEqualTo,
+ LessThan,
+ LessThanOrEqualTo,
+ EqualTo,
+ NotEqualTo,
+ BitwiseAnd,
+ BitwiseOr,
+ LeftShift,
+ RightShift
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/QuotedRegionKind.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/QuotedRegionKind.cs
new file mode 100644
index 000000000000..8aa26d00dc28
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/QuotedRegionKind.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Core.Expressions.Cpp
+{
+ public enum QuotedRegionKind
+ {
+ None,
+ DoubleQuoteRegion,
+ SingleQuoteRegion
+ }
+}
diff --git a/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/Scope.cs b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/Scope.cs
new file mode 100644
index 000000000000..e3f9714155fe
--- /dev/null
+++ b/src/TemplateEngine/Microsoft.TemplateEngine.Core/Expressions/Cpp/Scope.cs
@@ -0,0 +1,122 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.TemplateEngine.Utils;
+
+namespace Microsoft.TemplateEngine.Core.Expressions.Cpp
+{
+ internal class Scope
+ {
+ public enum NextPlacement
+ {
+ Left,
+ Right,
+ None
+ }
+
+ public object? Left { get; set; }
+
+ public Operator Operator { get; set; }
+
+ public object? Right { get; set; }
+
+ public object Value
+ {
+ set
+ {
+ switch (TargetPlacement)
+ {
+ case NextPlacement.Left:
+ Left = value;
+ TargetPlacement = NextPlacement.Right;
+ break;
+ case NextPlacement.Right:
+ Right = value;
+ TargetPlacement = NextPlacement.None;
+ break;
+ }
+ }
+ }
+
+ public NextPlacement TargetPlacement { get; set; }
+
+ public static TResult EvaluateSides(object left, object right, Func convertLeft, Func convertRight, Func combine)
+ {
+ TLeft l = EvaluateSide(left, convertLeft);
+ TRight r = EvaluateSide(right, convertRight);
+ return combine(l, r);
+ }
+
+ public static TResult EvaluateSides(object left, object right, Func convert, Func combine)
+ {
+ return EvaluateSides(left, right, convert, convert, combine);
+ }
+
+ public object Evaluate()
+ {
+ switch (Operator)
+ {
+ case Operator.Not:
+ return !EvaluateSide(Right!, x => Convert.ToBoolean(x ?? "False"));
+ case Operator.And:
+ return EvaluateSides(Left!, Right!, x => (bool)x, (x, y) => x && y);
+ case Operator.Or:
+ return EvaluateSides(Left!, Right!, x => (bool)x, (x, y) => x || y);
+ case Operator.Xor:
+ return EvaluateSides(Left!, Right!, x => (bool)x, (x, y) => x ^ y);
+ case Operator.EqualTo:
+ return EvaluateSides(Left!, Right!, x => x, LenientEquals);
+ case Operator.NotEqualTo:
+ return EvaluateSides(Left!, Right!, x => x, (x, y) => !LenientEquals(x, y));
+ case Operator.GreaterThan:
+ return EvaluateSides(Left!, Right!, ParserExtensions.ConvertToDoubleCurrentOrInvariant, (x, y) => x > y);
+ case Operator.GreaterThanOrEqualTo:
+ return EvaluateSides(Left!, Right!, ParserExtensions.ConvertToDoubleCurrentOrInvariant, (x, y) => x >= y);
+ case Operator.LessThan:
+ return EvaluateSides(Left!, Right!, ParserExtensions.ConvertToDoubleCurrentOrInvariant, (x, y) => x < y);
+ case Operator.LessThanOrEqualTo:
+ return EvaluateSides(Left!, Right!, ParserExtensions.ConvertToDoubleCurrentOrInvariant, (x, y) => x <= y);
+ case Operator.LeftShift:
+ return EvaluateSides(Left!, Right!, Convert.ToInt64, Convert.ToInt32, (x, y) => x << y);
+ case Operator.RightShift:
+ return EvaluateSides(Left!, Right!, Convert.ToInt64, Convert.ToInt32, (x, y) => x >> y);
+ case Operator.BitwiseAnd:
+ return EvaluateSides(Left!, Right!, Convert.ToInt64, (x, y) => x & y);
+ case Operator.BitwiseOr:
+ return EvaluateSides(Left!, Right!, Convert.ToInt64, (x, y) => x | y);
+ default:
+ if (Left != null)
+ {
+ return EvaluateSide(Left, x => x);
+ }
+
+ return false;
+ }
+ }
+
+ private static T EvaluateSide