From 403234a4c4247151d09073bc07ccc13530ce62c6 Mon Sep 17 00:00:00 2001
From: Jon Sequeira <jonsequeira@gmail.com>
Date: Fri, 31 Mar 2023 04:31:26 -0700
Subject: [PATCH] rename symbol types with Cli prefix; some property renames
 and file moves (#2132)

---
 samples/HostingPlayground/Program.cs          |   6 +-
 src/Common/ArgumentBuilder.cs                 |  14 +-
 src/Common/OptionBuilder.cs                   |  14 +-
 ...ne_Hosting_api_is_not_changed.approved.txt |   4 +-
 ...tionBinder_api_is_not_changed.approved.txt |   8 +-
 ...ommandLine_api_is_not_changed.approved.txt | 221 ++++-----
 .../LocalizationTests.cs                      |   4 +-
 .../Perf_Parser_CustomScenarios.cs            |   8 +-
 .../Perf_Parser_Directives_Suggest.cs         |   9 +-
 .../CommandLine/Perf_Parser_NestedCommands.cs |  10 +-
 .../CommandLine/Perf_Parser_Options_Bare.cs   |   6 +-
 .../Perf_Parser_Options_With_Arguments.cs     |   4 +-
 .../CommandLine/Perf_Parser_ParseResult.cs    |   7 +-
 .../CommandLine/Perf_Parser_Simple.cs         |  10 +-
 .../CommandLine/Perf_Parser_TypoCorrection.cs |   4 +-
 .../CommandLine/Perf_Suggestions.cs           |  10 +-
 .../Helpers/Utils.cs                          |   4 +-
 .../ConfigureFromMethodTests.cs               |  28 +-
 .../CommandLine.cs                            |  10 +-
 .../CommandExtensions.cs                      |   6 +-
 .../GeneratedCommandHandlerTests.cs           |  64 +--
 .../CommandHandlerSourceGenerator.cs          |   2 +-
 .../SyntaxReceiver.cs                         |   6 +-
 .../HostingHandlerTest.cs                     |  16 +-
 .../HostingTests.cs                           |  20 +-
 .../DirectiveConfigurationExtensions.cs       |   2 +-
 .../HostingAction.cs                          |   6 +-
 .../HostingExtensions.cs                      |   4 +-
 .../ModelBinderTests.cs                       | 150 +++---
 ...indingCommandHandlerTests.BindingByName.cs |  12 +-
 .../ModelBindingCommandHandlerTests.cs        |  16 +-
 .../ParameterBindingTests.cs                  |  90 ++--
 .../BindingContext.cs                         |   4 +-
 .../CommandResultExtensions.cs                |   4 +-
 .../ModelBinder.cs                            |   2 +-
 .../ModelBinder{T}.cs                         |   2 +-
 .../ModelBindingCommandHandler.cs             |   8 +-
 .../SpecificSymbolValueSource.cs              |   8 +-
 .../TableRenderingTests.cs                    |  20 +-
 .../ViewRenderingTests.cs                     |   2 +-
 .../EndToEndTestApp/Program.cs                |  10 +-
 .../SuggestionDispatcherTests.cs              |   2 +-
 .../SuggestionDispatcher.cs                   |  35 +-
 src/System.CommandLine.Tests/ArgumentTests.cs | 150 +++---
 .../Binding/TypeConversionTests.cs            | 198 ++++----
 .../CommandLineConfigurationTests.cs          |  70 +--
 src/System.CommandLine.Tests/CommandTests.cs  |  52 +-
 .../CompilationTests.cs                       |   2 +-
 .../CompletionContextTests.cs                 |  68 +--
 .../CompletionTests.cs                        | 304 ++++++------
 .../DirectiveTests.cs                         |  44 +-
 .../EnvironmentVariableDirectiveTests.cs      |  14 +-
 .../GetValueByNameParserTests.cs              |  88 ++--
 .../GetValueByNameTypeConversionTests.cs      |   8 +-
 .../GlobalOptionTests.cs                      |  48 +-
 .../Help/HelpBuilderExtensions.cs             |   2 +-
 .../Help/HelpBuilderTests.Approval.cs         |  32 +-
 .../Help/HelpBuilderTests.Customization.cs    |  74 +--
 .../Help/HelpBuilderTests.cs                  | 414 ++++++++--------
 .../HelpOptionTests.cs                        |  38 +-
 .../CancelOnProcessTerminationTests.cs        |   4 +-
 .../Invocation/InvocationTests.cs             |  26 +-
 .../Invocation/TypoCorrectionTests.cs         |  50 +-
 .../OptionTests.MultipleArgumentsPerToken.cs  |  40 +-
 src/System.CommandLine.Tests/OptionTests.cs   |  90 ++--
 .../ParseDiagramTests.cs                      |  46 +-
 .../ParseDirectiveTests.cs                    |  45 +-
 .../ParseResultTests.cs                       |  42 +-
 .../ParserTests.DoubleDash.cs                 |  22 +-
 .../ParserTests.MultipleArguments.cs          |  76 +--
 .../ParserTests.MultiplePositions.cs          |  46 +-
 .../ParserTests.RootCommandAndArg0.cs         |  40 +-
 src/System.CommandLine.Tests/ParserTests.cs   | 458 +++++++++---------
 .../ParsingValidationTests.cs                 | 266 +++++-----
 .../ResponseFileTests.cs                      |  96 ++--
 .../RootCommandTests.cs                       |   4 +-
 .../SuggestDirectiveTests.cs                  |  47 +-
 .../TestApps/NativeAOT/Program.cs             |   6 +-
 .../TestApps/Trimming/Program.cs              |   4 +-
 .../TokenReplacementTests.cs                  |  36 +-
 .../UseExceptionHandlerTests.cs               |   8 +-
 .../UseParseErrorReportingTests.cs            |   8 +-
 .../Utility/ParseResultExtensions.cs          |   2 +-
 .../VersionOptionTests.cs                     |  30 +-
 src/System.CommandLine/AliasSet.cs            |   4 +-
 src/System.CommandLine/ArgumentArity.cs       |  12 +-
 src/System.CommandLine/ArgumentValidation.cs  |  10 +-
 src/System.CommandLine/Argument{T}.cs         |   6 +-
 .../Binding/ArgumentConverter.cs              |   2 +-
 .../{ChildList.cs => ChildSymbolList{T}.cs}   |   6 +-
 .../{Argument.cs => CliArgument.cs}           |  10 +-
 .../{Command.cs => CliCommand.cs}             |  42 +-
 .../{Directive.cs => CliDirective.cs}         |   4 +-
 .../{Option.cs => CliOption.cs}               |  27 +-
 .../{RootCommand.cs => CliRootCommand.cs}     |   6 +-
 .../{Symbol.cs => CliSymbol.cs}               |  10 +-
 .../CommandLineConfiguration.cs               |  17 +-
 .../{ => Completions}/SuggestDirective.cs     |   4 +-
 .../EnvironmentVariablesDirective.cs          |   2 +-
 .../Help/HelpBuilder.Default.cs               |  36 +-
 src/System.CommandLine/Help/HelpBuilder.cs    |  54 +--
 .../Help/HelpBuilderExtensions.cs             |   4 +-
 src/System.CommandLine/Help/HelpContext.cs    |   4 +-
 src/System.CommandLine/Help/HelpOption.cs     |  12 +-
 ...rorResult.cs => ParseErrorResultAction.cs} |   0
 ...oCorrection.cs => TypoCorrectionAction.cs} |   6 +-
 src/System.CommandLine/OptionValidation.cs    |  10 +-
 src/System.CommandLine/Option{T}.cs           |  23 +-
 src/System.CommandLine/ParentNode.cs          |   4 +-
 ...eDirective.cs => ParseDiagramDirective.cs} |  22 +-
 src/System.CommandLine/ParseResult.cs         |  26 +-
 .../Parsing/ArgumentResult.cs                 |  14 +-
 .../Parsing/CommandResult.cs                  |  13 +-
 .../Parsing/DirectiveResult.cs                |   4 +-
 .../Parsing/OptionResult.cs                   |  10 +-
 ...rectiveAction.cs => ParseDiagramAction.cs} |  16 +-
 .../Parsing/ParseOperation.cs                 |  10 +-
 src/System.CommandLine/Parsing/Parser.cs      |   6 +-
 .../Parsing/StringExtensions.cs               |  48 +-
 .../Parsing/SymbolResult.cs                   |  20 +-
 .../Parsing/SymbolResultTree.cs               |  12 +-
 src/System.CommandLine/Parsing/Token.cs       |   8 +-
 src/System.CommandLine/Parsing/TokenType.cs   |   8 +-
 src/System.CommandLine/SymbolExtensions.cs    |   8 +-
 .../{Help => }/VersionOption.cs               |  20 +-
 125 files changed, 2271 insertions(+), 2259 deletions(-)
 rename src/System.CommandLine/{ChildList.cs => ChildSymbolList{T}.cs} (90%)
 rename src/System.CommandLine/{Argument.cs => CliArgument.cs} (92%)
 rename src/System.CommandLine/{Command.cs => CliCommand.cs} (90%)
 rename src/System.CommandLine/{Directive.cs => CliDirective.cs} (94%)
 rename src/System.CommandLine/{Option.cs => CliOption.cs} (84%)
 rename src/System.CommandLine/{RootCommand.cs => CliRootCommand.cs} (90%)
 rename src/System.CommandLine/{Symbol.cs => CliSymbol.cs} (92%)
 rename src/System.CommandLine/{ => Completions}/SuggestDirective.cs (96%)
 rename src/System.CommandLine/Invocation/{ParseErrorResult.cs => ParseErrorResultAction.cs} (100%)
 rename src/System.CommandLine/Invocation/{TypoCorrection.cs => TypoCorrectionAction.cs} (95%)
 rename src/System.CommandLine/{ParseDirective.cs => ParseDiagramDirective.cs} (50%)
 rename src/System.CommandLine/Parsing/{ParseDirectiveAction.cs => ParseDiagramAction.cs} (92%)
 rename src/System.CommandLine/{Help => }/VersionOption.cs (70%)

diff --git a/samples/HostingPlayground/Program.cs b/samples/HostingPlayground/Program.cs
index 3f91ffec37..cd05f33386 100644
--- a/samples/HostingPlayground/Program.cs
+++ b/samples/HostingPlayground/Program.cs
@@ -24,9 +24,9 @@ static Task Main(string[] args) => BuildCommandLine()
 
         private static CommandLineConfiguration BuildCommandLine()
         {
-            var root = new RootCommand(@"$ dotnet run --name 'Joe'"){
-                new Option<string>("--name"){
-                    IsRequired = true
+            var root = new CliRootCommand(@"$ dotnet run --name 'Joe'"){
+                new CliOption<string>("--name"){
+                    Required = true
                 }
             };
             root.Action = CommandHandler.Create<GreeterOptions, IHost>(Run);
diff --git a/src/Common/ArgumentBuilder.cs b/src/Common/ArgumentBuilder.cs
index 5c24853f32..5d707e91ad 100644
--- a/src/Common/ArgumentBuilder.cs
+++ b/src/Common/ArgumentBuilder.cs
@@ -9,12 +9,12 @@ internal static class ArgumentBuilder
 
     static ArgumentBuilder()
     {
-        _ctor = typeof(Argument<string>).GetConstructor(new[] { typeof(string) });
+        _ctor = typeof(CliArgument<string>).GetConstructor(new[] { typeof(string) });
     }
 
-    public static Argument CreateArgument(Type valueType, string name = "value")
+    public static CliArgument CreateArgument(Type valueType, string name = "value")
     {
-        var argumentType = typeof(Argument<>).MakeGenericType(valueType);
+        var argumentType = typeof(CliArgument<>).MakeGenericType(valueType);
 
 #if NET6_0_OR_GREATER
         var ctor = (ConstructorInfo)argumentType.GetMemberWithSameMetadataDefinitionAs(_ctor);
@@ -22,10 +22,10 @@ public static Argument CreateArgument(Type valueType, string name = "value")
         var ctor = argumentType.GetConstructor(new[] { typeof(string) });
 #endif
 
-        return (Argument)ctor.Invoke(new object[] { name });
+        return (CliArgument)ctor.Invoke(new object[] { name });
     }
 
-    internal static Argument CreateArgument(ParameterInfo argsParam)
+    internal static CliArgument CreateArgument(ParameterInfo argsParam)
     {
         if (!argsParam.HasDefaultValue)
         {
@@ -36,10 +36,10 @@ internal static Argument CreateArgument(ParameterInfo argsParam)
 
         var ctor = argumentType.GetConstructor(new[] { typeof(string), argsParam.ParameterType });
 
-        return (Argument)ctor.Invoke(new object[] { argsParam.Name, argsParam.DefaultValue });
+        return (CliArgument)ctor.Invoke(new object[] { argsParam.Name, argsParam.DefaultValue });
     }
 
-    private sealed class Bridge<T> : Argument<T>
+    private sealed class Bridge<T> : CliArgument<T>
     {
         public Bridge(string name, T defaultValue)
             : base(name)
diff --git a/src/Common/OptionBuilder.cs b/src/Common/OptionBuilder.cs
index fa9ca5d232..768b3eddec 100644
--- a/src/Common/OptionBuilder.cs
+++ b/src/Common/OptionBuilder.cs
@@ -11,12 +11,12 @@ internal static class OptionBuilder
 
     static OptionBuilder()
     {
-        _ctor = typeof(Option<string>).GetConstructor(new[] { typeof(string), typeof(string[]) });
+        _ctor = typeof(CliOption<string>).GetConstructor(new[] { typeof(string), typeof(string[]) });
     }
 
-    internal static Option CreateOption(string name, Type valueType, string description = null)
+    internal static CliOption CreateOption(string name, Type valueType, string description = null)
     {
-        var optionType = typeof(Option<>).MakeGenericType(valueType);
+        var optionType = typeof(CliOption<>).MakeGenericType(valueType);
 
 #if NET6_0_OR_GREATER
         var ctor = (ConstructorInfo)optionType.GetMemberWithSameMetadataDefinitionAs(_ctor);
@@ -24,14 +24,14 @@ internal static Option CreateOption(string name, Type valueType, string descript
         var ctor = optionType.GetConstructor(new[] { typeof(string), typeof(string[]) });
 #endif
 
-        var option = (Option)ctor.Invoke(new object[] { name, Array.Empty<string>() });
+        var option = (CliOption)ctor.Invoke(new object[] { name, Array.Empty<string>() });
 
         option.Description = description;
 
         return option;
     }
 
-    internal static Option CreateOption(string name, Type valueType, string description, Func<object> defaultValueFactory)
+    internal static CliOption CreateOption(string name, Type valueType, string description, Func<object> defaultValueFactory)
     {
         if (defaultValueFactory == null)
         {
@@ -42,12 +42,12 @@ internal static Option CreateOption(string name, Type valueType, string descript
 
         var ctor = optionType.GetConstructor(new[] { typeof(string), typeof(Func<object>), typeof(string) });
 
-        var option = (Option)ctor.Invoke(new object[] { name, defaultValueFactory, description });
+        var option = (CliOption)ctor.Invoke(new object[] { name, defaultValueFactory, description });
 
         return option;
     }
 
-    private sealed class Bridge<T> : Option<T>
+    private sealed class Bridge<T> : CliOption<T>
     {
         public Bridge(string name, Func<object> defaultValueFactory, string description)
             : base(name)
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_Hosting_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_Hosting_api_is_not_changed.approved.txt
index d419f8902a..5e9f1af93c 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_Hosting_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_Hosting_api_is_not_changed.approved.txt
@@ -1,12 +1,12 @@
 System.CommandLine.Hosting
   public static class DirectiveConfigurationExtensions
-    public static Microsoft.Extensions.Configuration.IConfigurationBuilder AddCommandLineDirectives(this Microsoft.Extensions.Configuration.IConfigurationBuilder config, System.CommandLine.ParseResult commandline, System.CommandLine.Directive directive)
+    public static Microsoft.Extensions.Configuration.IConfigurationBuilder AddCommandLineDirectives(this Microsoft.Extensions.Configuration.IConfigurationBuilder config, System.CommandLine.ParseResult commandline, System.CommandLine.CliDirective directive)
   public static class HostingExtensions
     public static OptionsBuilder<TOptions> BindCommandLine<TOptions>(this OptionsBuilder<TOptions> optionsBuilder)
     public static Microsoft.Extensions.Hosting.IHost GetHost(this System.CommandLine.ParseResult parseResult)
     public static System.CommandLine.ParseResult GetParseResult(this Microsoft.Extensions.Hosting.IHostBuilder hostBuilder)
     public static System.CommandLine.ParseResult GetParseResult(this Microsoft.Extensions.Hosting.HostBuilderContext context)
-    public static System.CommandLine.Command UseCommandHandler<THandler>(this System.CommandLine.Command command)
+    public static System.CommandLine.CliCommand UseCommandHandler<THandler>(this System.CommandLine.CliCommand command)
     public static System.CommandLine.CommandLineConfiguration UseHost(this System.CommandLine.CommandLineConfiguration builder, System.Action<Microsoft.Extensions.Hosting.IHostBuilder> configureHost = null)
     public static System.CommandLine.CommandLineConfiguration UseHost(this System.CommandLine.CommandLineConfiguration builder, System.Func<System.String[],Microsoft.Extensions.Hosting.IHostBuilder> hostBuilderFactory, System.Action<Microsoft.Extensions.Hosting.IHostBuilder> configureHost = null)
     public static Microsoft.Extensions.Hosting.IHostBuilder UseInvocationLifetime(this Microsoft.Extensions.Hosting.IHostBuilder host, System.Action<InvocationLifetimeOptions> configureOptions = null)
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt
index c8ab50bdd7..3b24de558b 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt
@@ -109,16 +109,16 @@ System.CommandLine.NamingConventionBinder
     public System.Boolean EnforceExplicitBinding { get; set; }
     public ModelDescriptor ModelDescriptor { get; }
     public System.CommandLine.Binding.IValueDescriptor ValueDescriptor { get; }
-    public System.Void BindMemberFromValue(System.Reflection.PropertyInfo property, System.CommandLine.Symbol symbol)
+    public System.Void BindMemberFromValue(System.Reflection.PropertyInfo property, System.CommandLine.CliSymbol symbol)
     public System.Object CreateInstance(System.CommandLine.Binding.BindingContext bindingContext)
     public System.Void UpdateInstance<T>(T instance, System.CommandLine.Binding.BindingContext bindingContext)
   public class ModelBinder<TModel> : ModelBinder
     .ctor()
-    public System.Void BindMemberFromValue<TValue>(Expression<Func<TModel,TValue>> property, System.CommandLine.Symbol symbol)
+    public System.Void BindMemberFromValue<TValue>(Expression<Func<TModel,TValue>> property, System.CommandLine.CliSymbol symbol)
     public System.Void BindMemberFromValue<TValue>(Expression<Func<TModel,TValue>> property, Func<System.CommandLine.Binding.BindingContext,TValue> getValue)
   public class ModelBindingCommandHandler : BindingHandler
-    public System.Void BindParameter(System.Reflection.ParameterInfo param, System.CommandLine.Argument argument)
-    public System.Void BindParameter(System.Reflection.ParameterInfo param, System.CommandLine.Option option)
+    public System.Void BindParameter(System.Reflection.ParameterInfo param, System.CommandLine.CliArgument argument)
+    public System.Void BindParameter(System.Reflection.ParameterInfo param, System.CommandLine.CliOption option)
     public System.Int32 Invoke(System.CommandLine.ParseResult parseResult)
     public System.Threading.Tasks.Task<System.Int32> InvokeAsync(System.CommandLine.ParseResult parseResult, System.Threading.CancellationToken cancellationToken = null)
   public class ModelDescriptor
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
index 3b31cc7dca..1e546fd4a4 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -1,5 +1,25 @@
 System.CommandLine
-  public abstract class Argument : Symbol
+  public struct ArgumentArity : System.ValueType, System.IEquatable<ArgumentArity>
+    public static ArgumentArity ExactlyOne { get; }
+    public static ArgumentArity OneOrMore { get; }
+    public static ArgumentArity Zero { get; }
+    public static ArgumentArity ZeroOrMore { get; }
+    public static ArgumentArity ZeroOrOne { get; }
+    .ctor(System.Int32 minimumNumberOfValues, System.Int32 maximumNumberOfValues)
+    public System.Int32 MaximumNumberOfValues { get; }
+    public System.Int32 MinimumNumberOfValues { get; }
+    public System.Boolean Equals(ArgumentArity other)
+    public System.Boolean Equals(System.Object obj)
+    public System.Int32 GetHashCode()
+  public static class ArgumentValidation
+    public static CliArgument<System.IO.FileInfo> AcceptExistingOnly(this CliArgument<System.IO.FileInfo> argument)
+    public static CliArgument<System.IO.DirectoryInfo> AcceptExistingOnly(this CliArgument<System.IO.DirectoryInfo> argument)
+    public static CliArgument<System.IO.FileSystemInfo> AcceptExistingOnly(this CliArgument<System.IO.FileSystemInfo> argument)
+    public static CliArgument<T> AcceptExistingOnly<T>(this CliArgument<T> argument)
+  public abstract class CliAction
+    public System.Int32 Invoke(ParseResult parseResult)
+    public System.Threading.Tasks.Task<System.Int32> InvokeAsync(ParseResult parseResult, System.Threading.CancellationToken cancellationToken = null)
+  public abstract class CliArgument : CliSymbol
     public ArgumentArity Arity { get; set; }
     public System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> CompletionSources { get; }
     public System.Boolean HasDefaultValue { get; }
@@ -9,7 +29,7 @@ System.CommandLine
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
     public System.Object GetDefaultValue()
     public System.String ToString()
-  public class Argument<T> : Argument
+  public class CliArgument<T> : CliArgument
     .ctor(System.String name)
     public Func<System.CommandLine.Parsing.ArgumentResult,T> CustomParser { get; set; }
     public Func<System.CommandLine.Parsing.ArgumentResult,T> DefaultValueFactory { get; set; }
@@ -18,48 +38,63 @@ System.CommandLine
     public System.Void AcceptLegalFileNamesOnly()
     public System.Void AcceptLegalFilePathsOnly()
     public System.Void AcceptOnlyFromAmong(System.String[] values)
-  public struct ArgumentArity : System.ValueType, System.IEquatable<ArgumentArity>
-    public static ArgumentArity ExactlyOne { get; }
-    public static ArgumentArity OneOrMore { get; }
-    public static ArgumentArity Zero { get; }
-    public static ArgumentArity ZeroOrMore { get; }
-    public static ArgumentArity ZeroOrOne { get; }
-    .ctor(System.Int32 minimumNumberOfValues, System.Int32 maximumNumberOfValues)
-    public System.Int32 MaximumNumberOfValues { get; }
-    public System.Int32 MinimumNumberOfValues { get; }
-    public System.Boolean Equals(ArgumentArity other)
-    public System.Boolean Equals(System.Object obj)
-    public System.Int32 GetHashCode()
-  public static class ArgumentValidation
-    public static Argument<System.IO.FileInfo> AcceptExistingOnly(this Argument<System.IO.FileInfo> argument)
-    public static Argument<System.IO.DirectoryInfo> AcceptExistingOnly(this Argument<System.IO.DirectoryInfo> argument)
-    public static Argument<System.IO.FileSystemInfo> AcceptExistingOnly(this Argument<System.IO.FileSystemInfo> argument)
-    public static Argument<T> AcceptExistingOnly<T>(this Argument<T> argument)
-  public abstract class CliAction
-    public System.Int32 Invoke(ParseResult parseResult)
-    public System.Threading.Tasks.Task<System.Int32> InvokeAsync(ParseResult parseResult, System.Threading.CancellationToken cancellationToken = null)
-  public class Command : Symbol, System.Collections.Generic.IEnumerable<Symbol>, System.Collections.IEnumerable
+  public class CliCommand : CliSymbol, System.Collections.Generic.IEnumerable<CliSymbol>, System.Collections.IEnumerable
     .ctor(System.String name, System.String description = null)
     public CliAction Action { get; set; }
     public System.Collections.Generic.ICollection<System.String> Aliases { get; }
-    public System.Collections.Generic.IList<Argument> Arguments { get; }
-    public System.Collections.Generic.IEnumerable<Symbol> Children { get; }
-    public System.Collections.Generic.IList<Option> Options { get; }
-    public System.Collections.Generic.IList<Command> Subcommands { get; }
+    public System.Collections.Generic.IList<CliArgument> Arguments { get; }
+    public System.Collections.Generic.IEnumerable<CliSymbol> Children { get; }
+    public System.Collections.Generic.IList<CliOption> Options { get; }
+    public System.Collections.Generic.IList<CliCommand> Subcommands { get; }
     public System.Boolean TreatUnmatchedTokensAsErrors { get; set; }
     public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.CommandResult>> Validators { get; }
-    public System.Void Add(Symbol symbol)
+    public System.Void Add(CliSymbol symbol)
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
-    public System.Collections.Generic.IEnumerator<Symbol> GetEnumerator()
+    public System.Collections.Generic.IEnumerator<CliSymbol> GetEnumerator()
     public ParseResult Parse(System.Collections.Generic.IReadOnlyList<System.String> args, CommandLineConfiguration configuration = null)
     public ParseResult Parse(System.String commandLine, CommandLineConfiguration configuration = null)
     public System.Void SetAction(System.Action<ParseResult> action)
     public System.Void SetAction(System.Func<ParseResult,System.Int32> action)
     public System.Void SetAction(System.Func<ParseResult,System.Threading.CancellationToken,System.Threading.Tasks.Task> action)
     public System.Void SetAction(System.Func<ParseResult,System.Threading.CancellationToken,System.Threading.Tasks.Task<System.Int32>> action)
+  public class CliDirective : CliSymbol
+    .ctor(System.String name)
+    public CliAction Action { get; set; }
+    public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
+  public abstract class CliOption : CliSymbol
+    public CliAction Action { get; set; }
+    public System.Collections.Generic.ICollection<System.String> Aliases { get; }
+    public System.Boolean AllowMultipleArgumentsPerToken { get; set; }
+    public ArgumentArity Arity { get; set; }
+    public System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> CompletionSources { get; }
+    public System.String HelpName { get; set; }
+    public System.Boolean Recursive { get; set; }
+    public System.Boolean Required { get; set; }
+    public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.OptionResult>> Validators { get; }
+    public System.Type ValueType { get; }
+    public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
+  public class CliOption<T> : CliOption
+    .ctor(System.String name, System.String[] aliases)
+    public Func<System.CommandLine.Parsing.ArgumentResult,T> CustomParser { get; set; }
+    public Func<System.CommandLine.Parsing.ArgumentResult,T> DefaultValueFactory { get; set; }
+    public System.Type ValueType { get; }
+    public System.Void AcceptLegalFileNamesOnly()
+    public System.Void AcceptLegalFilePathsOnly()
+    public System.Void AcceptOnlyFromAmong(System.String[] values)
+  public class CliRootCommand : CliCommand, System.Collections.Generic.IEnumerable<CliSymbol>, System.Collections.IEnumerable
+    public static System.String ExecutableName { get; }
+    public static System.String ExecutablePath { get; }
+    .ctor(System.String description = )
+  public abstract class CliSymbol
+    public System.String Description { get; set; }
+    public System.Boolean Hidden { get; set; }
+    public System.String Name { get; }
+    public System.Collections.Generic.IEnumerable<CliSymbol> Parents { get; }
+    public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
+    public System.String ToString()
   public class CommandLineConfiguration
-    .ctor(Command rootCommand)
-    public System.Collections.Generic.List<Directive> Directives { get; }
+    .ctor(CliCommand rootCommand)
+    public System.Collections.Generic.List<CliDirective> Directives { get; }
     public System.Boolean EnableDefaultExceptionHandler { get; set; }
     public System.Boolean EnableParseErrorReporting { get; set; }
     public System.Boolean EnablePosixBundling { get; set; }
@@ -68,7 +103,7 @@ System.CommandLine
     public System.IO.TextWriter Output { get; set; }
     public System.Nullable<System.TimeSpan> ProcessTerminationTimeout { get; set; }
     public System.CommandLine.Parsing.TryReplaceToken ResponseFileTokenReplacer { get; set; }
-    public Command RootCommand { get; }
+    public CliCommand RootCommand { get; }
     public System.Int32 Invoke(System.String commandLine)
     public System.Int32 Invoke(System.String[] args)
     public System.Threading.Tasks.Task<System.Int32> InvokeAsync(System.String commandLine, System.Threading.CancellationToken cancellationToken = null)
@@ -81,39 +116,18 @@ System.CommandLine
   public static class CompletionSourceExtensions
     public static System.Void Add(this System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> completionSources, System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.String>> completionsDelegate)
     public static System.Void Add(this System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> completionSources, System.String[] completions)
-  public class Directive : Symbol
-    .ctor(System.String name)
-    public CliAction Action { get; set; }
-    public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
-  public class EnvironmentVariablesDirective : Directive
+  public class EnvironmentVariablesDirective : CliDirective
     .ctor()
     public CliAction Action { get; set; }
-  public abstract class Option : Symbol
-    public CliAction Action { get; set; }
-    public System.Collections.Generic.ICollection<System.String> Aliases { get; }
-    public System.Boolean AllowMultipleArgumentsPerToken { get; set; }
-    public System.Boolean AppliesToSelfAndChildren { get; set; }
-    public ArgumentArity Arity { get; set; }
-    public System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> CompletionSources { get; }
-    public System.String HelpName { get; set; }
-    public System.Boolean IsRequired { get; set; }
-    public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.OptionResult>> Validators { get; }
-    public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
-  public class Option<T> : Option
-    .ctor(System.String name, System.String[] aliases)
-    public Func<System.CommandLine.Parsing.ArgumentResult,T> CustomParser { get; set; }
-    public Func<System.CommandLine.Parsing.ArgumentResult,T> DefaultValueFactory { get; set; }
-    public System.Void AcceptLegalFileNamesOnly()
-    public System.Void AcceptLegalFilePathsOnly()
-    public System.Void AcceptOnlyFromAmong(System.String[] values)
   public static class OptionValidation
-    public static Option<System.IO.FileInfo> AcceptExistingOnly(this Option<System.IO.FileInfo> option)
-    public static Option<System.IO.DirectoryInfo> AcceptExistingOnly(this Option<System.IO.DirectoryInfo> option)
-    public static Option<System.IO.FileSystemInfo> AcceptExistingOnly(this Option<System.IO.FileSystemInfo> option)
-    public static Option<T> AcceptExistingOnly<T>(this Option<T> option)
-  public class ParseDirective : Directive
-    .ctor(System.Int32 errorExitCode = 1)
+    public static CliOption<System.IO.FileInfo> AcceptExistingOnly(this CliOption<System.IO.FileInfo> option)
+    public static CliOption<System.IO.DirectoryInfo> AcceptExistingOnly(this CliOption<System.IO.DirectoryInfo> option)
+    public static CliOption<System.IO.FileSystemInfo> AcceptExistingOnly(this CliOption<System.IO.FileSystemInfo> option)
+    public static CliOption<T> AcceptExistingOnly<T>(this CliOption<T> option)
+  public class ParseDiagramDirective : CliDirective
+    .ctor()
     public CliAction Action { get; set; }
+    public System.Int32 ParseErrorReturnValue { get; set; }
   public class ParseResult
     public CliAction Action { get; }
     public System.CommandLine.Parsing.CommandResult CommandResult { get; }
@@ -122,34 +136,20 @@ System.CommandLine
     public System.CommandLine.Parsing.CommandResult RootCommandResult { get; }
     public System.Collections.Generic.IReadOnlyList<System.CommandLine.Parsing.Token> Tokens { get; }
     public System.String[] UnmatchedTokens { get; }
-    public System.CommandLine.Parsing.ArgumentResult FindResultFor(Argument argument)
-    public System.CommandLine.Parsing.CommandResult FindResultFor(Command command)
-    public System.CommandLine.Parsing.OptionResult FindResultFor(Option option)
-    public System.CommandLine.Parsing.DirectiveResult FindResultFor(Directive directive)
-    public System.CommandLine.Parsing.SymbolResult FindResultFor(Symbol symbol)
+    public System.CommandLine.Parsing.ArgumentResult FindResultFor(CliArgument argument)
+    public System.CommandLine.Parsing.CommandResult FindResultFor(CliCommand command)
+    public System.CommandLine.Parsing.OptionResult FindResultFor(CliOption option)
+    public System.CommandLine.Parsing.DirectiveResult FindResultFor(CliDirective directive)
+    public System.CommandLine.Parsing.SymbolResult FindResultFor(CliSymbol symbol)
     public System.CommandLine.Completions.CompletionContext GetCompletionContext()
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.Nullable<System.Int32> position = null)
-    public T GetValue<T>(Argument<T> argument)
-    public T GetValue<T>(Option<T> option)
+    public T GetValue<T>(CliArgument<T> argument)
+    public T GetValue<T>(CliOption<T> option)
     public T GetValue<T>(System.String name)
     public System.Int32 Invoke()
     public System.Threading.Tasks.Task<System.Int32> InvokeAsync(System.Threading.CancellationToken cancellationToken = null)
     public System.String ToString()
-  public class RootCommand : Command, System.Collections.Generic.IEnumerable<Symbol>, System.Collections.IEnumerable
-    public static System.String ExecutableName { get; }
-    public static System.String ExecutablePath { get; }
-    .ctor(System.String description = )
-  public class SuggestDirective : Directive
-    .ctor()
-    public CliAction Action { get; set; }
-  public abstract class Symbol
-    public System.String Description { get; set; }
-    public System.Boolean IsHidden { get; set; }
-    public System.String Name { get; }
-    public System.Collections.Generic.IEnumerable<Symbol> Parents { get; }
-    public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
-    public System.String ToString()
-  public class VersionOption : Option<System.Boolean>
+  public class VersionOption : CliOption<System.Boolean>
     .ctor()
     .ctor(System.String name, System.String[] aliases)
     public CliAction Action { get; set; }
@@ -172,6 +172,9 @@ System.CommandLine.Completions
     public System.Boolean Equals(System.Object obj)
     public System.Int32 GetHashCode()
     public System.String ToString()
+  public class SuggestDirective : System.CommandLine.CliDirective
+    .ctor()
+    public System.CommandLine.CliAction Action { get; set; }
   public class TextCompletionContext : CompletionContext
     public System.String CommandLineText { get; }
     public System.Int32 CursorPosition { get; }
@@ -186,32 +189,32 @@ System.CommandLine.Help
     .ctor(System.Int32 maxWidth = 2147483647)
     public System.Int32 MaxWidth { get; }
     public System.Void CustomizeLayout(System.Func<HelpContext,System.Collections.Generic.IEnumerable<System.Action<HelpContext>>> getLayout)
-    public System.Void CustomizeSymbol(System.CommandLine.Symbol symbol, System.Func<HelpContext,System.String> firstColumnText = null, System.Func<HelpContext,System.String> secondColumnText = null, System.Func<HelpContext,System.String> defaultValue = null)
-    public System.Void CustomizeSymbol(System.CommandLine.Symbol symbol, System.String firstColumnText = null, System.String secondColumnText = null, System.String defaultValue = null)
-    public TwoColumnHelpRow GetTwoColumnRow(System.CommandLine.Symbol symbol, HelpContext context)
+    public System.Void CustomizeSymbol(System.CommandLine.CliSymbol symbol, System.Func<HelpContext,System.String> firstColumnText = null, System.Func<HelpContext,System.String> secondColumnText = null, System.Func<HelpContext,System.String> defaultValue = null)
+    public System.Void CustomizeSymbol(System.CommandLine.CliSymbol symbol, System.String firstColumnText = null, System.String secondColumnText = null, System.String defaultValue = null)
+    public TwoColumnHelpRow GetTwoColumnRow(System.CommandLine.CliSymbol symbol, HelpContext context)
     public System.Void Write(HelpContext context)
-    public System.Void Write(System.CommandLine.Command command, System.IO.TextWriter writer)
+    public System.Void Write(System.CommandLine.CliCommand command, System.IO.TextWriter writer)
     public System.Void WriteColumns(System.Collections.Generic.IReadOnlyList<TwoColumnHelpRow> items, HelpContext context)
    static class Default
     public static System.Action<HelpContext> AdditionalArgumentsSection()
     public static System.Action<HelpContext> CommandArgumentsSection()
     public static System.Action<HelpContext> CommandUsageSection()
-    public static System.String GetArgumentDefaultValue(System.CommandLine.Argument argument)
-    public static System.String GetArgumentDescription(System.CommandLine.Argument argument)
-    public static System.String GetArgumentUsageLabel(System.CommandLine.Argument argument)
-    public static System.String GetCommandUsageLabel(System.CommandLine.Command symbol)
+    public static System.String GetArgumentDefaultValue(System.CommandLine.CliArgument argument)
+    public static System.String GetArgumentDescription(System.CommandLine.CliArgument argument)
+    public static System.String GetArgumentUsageLabel(System.CommandLine.CliArgument argument)
+    public static System.String GetCommandUsageLabel(System.CommandLine.CliCommand symbol)
     public static System.Collections.Generic.IEnumerable<System.Action<HelpContext>> GetLayout()
-    public static System.String GetOptionUsageLabel(System.CommandLine.Option symbol)
+    public static System.String GetOptionUsageLabel(System.CommandLine.CliOption symbol)
     public static System.Action<HelpContext> OptionsSection()
     public static System.Action<HelpContext> SubcommandsSection()
     public static System.Action<HelpContext> SynopsisSection()
   public class HelpContext
-    .ctor(HelpBuilder helpBuilder, System.CommandLine.Command command, System.IO.TextWriter output, System.CommandLine.ParseResult parseResult = null)
-    public System.CommandLine.Command Command { get; }
+    .ctor(HelpBuilder helpBuilder, System.CommandLine.CliCommand command, System.IO.TextWriter output, System.CommandLine.ParseResult parseResult = null)
+    public System.CommandLine.CliCommand Command { get; }
     public HelpBuilder HelpBuilder { get; }
     public System.IO.TextWriter Output { get; }
     public System.CommandLine.ParseResult ParseResult { get; }
-  public class HelpOption : System.CommandLine.Option<System.Boolean>
+  public class HelpOption : System.CommandLine.CliOption<System.Boolean>
     .ctor()
     .ctor(System.String name, System.String[] aliases)
     public System.CommandLine.CliAction Action { get; set; }
@@ -226,24 +229,24 @@ System.CommandLine.Help
     public System.Int32 GetHashCode()
 System.CommandLine.Parsing
   public class ArgumentResult : SymbolResult
-    public System.CommandLine.Argument Argument { get; }
+    public System.CommandLine.CliArgument Argument { get; }
     public System.Void AddError(System.String errorMessage)
     public T GetValueOrDefault<T>()
     public System.Void OnlyTake(System.Int32 numberOfTokens)
     public System.String ToString()
   public class CommandResult : SymbolResult
     public System.Collections.Generic.IEnumerable<SymbolResult> Children { get; }
-    public System.CommandLine.Command Command { get; }
+    public System.CommandLine.CliCommand Command { get; }
     public Token IdentifierToken { get; }
     public System.String ToString()
   public class DirectiveResult : SymbolResult
-    public System.CommandLine.Directive Directive { get; }
+    public System.CommandLine.CliDirective Directive { get; }
     public Token Token { get; }
     public System.Collections.Generic.IReadOnlyList<System.String> Values { get; }
   public class OptionResult : SymbolResult
     public Token IdentifierToken { get; }
-    public System.Boolean IsImplicit { get; }
-    public System.CommandLine.Option Option { get; }
+    public System.Boolean Implicit { get; }
+    public System.CommandLine.CliOption Option { get; }
     public T GetValueOrDefault<T>()
     public System.String ToString()
   public class ParseError
@@ -251,23 +254,23 @@ System.CommandLine.Parsing
     public SymbolResult SymbolResult { get; }
     public System.String ToString()
   public static class Parser
-    public static System.CommandLine.ParseResult Parse(System.CommandLine.Command command, System.Collections.Generic.IReadOnlyList<System.String> args, System.CommandLine.CommandLineConfiguration configuration = null)
-    public static System.CommandLine.ParseResult Parse(System.CommandLine.Command command, System.String commandLine, System.CommandLine.CommandLineConfiguration configuration = null)
+    public static System.CommandLine.ParseResult Parse(System.CommandLine.CliCommand command, System.Collections.Generic.IReadOnlyList<System.String> args, System.CommandLine.CommandLineConfiguration configuration = null)
+    public static System.CommandLine.ParseResult Parse(System.CommandLine.CliCommand command, System.String commandLine, System.CommandLine.CommandLineConfiguration configuration = null)
     public static System.Collections.Generic.IEnumerable<System.String> SplitCommandLine(System.String commandLine)
   public abstract class SymbolResult
     public SymbolResult Parent { get; }
     public System.Collections.Generic.IReadOnlyList<Token> Tokens { get; }
     public System.Void AddError(System.String errorMessage)
-    public ArgumentResult FindResultFor(System.CommandLine.Argument argument)
-    public CommandResult FindResultFor(System.CommandLine.Command command)
-    public OptionResult FindResultFor(System.CommandLine.Option option)
-    public DirectiveResult FindResultFor(System.CommandLine.Directive directive)
-    public T GetValue<T>(Argument<T> argument)
-    public T GetValue<T>(Option<T> option)
+    public ArgumentResult FindResultFor(System.CommandLine.CliArgument argument)
+    public CommandResult FindResultFor(System.CommandLine.CliCommand command)
+    public OptionResult FindResultFor(System.CommandLine.CliOption option)
+    public DirectiveResult FindResultFor(System.CommandLine.CliDirective directive)
+    public T GetValue<T>(CliArgument<T> argument)
+    public T GetValue<T>(CliOption<T> option)
   public class Token, System.IEquatable<Token>
     public static System.Boolean op_Equality(Token left, Token right)
     public static System.Boolean op_Inequality(Token left, Token right)
-    .ctor(System.String value, TokenType type, System.CommandLine.Symbol symbol)
+    .ctor(System.String value, TokenType type, System.CommandLine.CliSymbol symbol)
     public TokenType Type { get; }
     public System.String Value { get; }
     public System.Boolean Equals(System.Object obj)
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/LocalizationTests.cs b/src/System.CommandLine.ApiCompatibility.Tests/LocalizationTests.cs
index 3d730759b1..c861914005 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/LocalizationTests.cs
+++ b/src/System.CommandLine.ApiCompatibility.Tests/LocalizationTests.cs
@@ -19,9 +19,9 @@ public void ErrorMessages_AreLocalized(string cultureName, string expectedMessag
             {
                 CultureInfo.CurrentUICulture = new CultureInfo(cultureName);
 
-                Command command = new(CommandName)
+                CliCommand command = new(CommandName)
                 {
-                    new Argument<string>("arg")
+                    new CliArgument<string>("arg")
                 };
 
                 ParseResult parseResult = command.Parse(CommandName);
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
index 7417555cb6..63c6b70bea 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
@@ -13,15 +13,15 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_CustomScenarios
     {
         private string _testSymbolsAsString;
-        private Command _rootCommand;
+        private CliCommand _rootCommand;
         private CommandLineConfiguration _configuration;
 
         [GlobalSetup(Target = nameof(OneOptWithNestedCommand_Parse))]
         public void SetupOneOptWithNestedCommand()
         {
-            _rootCommand = new Command("root_command");
-            var nestedCommand = new Command("nested_command");
-            var option = new Option<int>("-opt1") { DefaultValueFactory = (_) => 123 };
+            _rootCommand = new CliCommand("root_command");
+            var nestedCommand = new CliCommand("nested_command");
+            var option = new CliOption<int>("-opt1") { DefaultValueFactory = (_) => 123 };
             nestedCommand.Options.Add(option);
             _rootCommand.Subcommands.Add(nestedCommand);
 
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
index 175e6d5997..a6216323c3 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Directives_Suggest.cs
@@ -1,8 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.CommandLine.Benchmarks.Helpers;
-using System.CommandLine.Parsing;
+using System.CommandLine.Completions;
 using System.Threading.Tasks;
 using BenchmarkDotNet.Attributes;
 
@@ -19,13 +18,13 @@ public class Perf_Parser_Directives_Suggest
         [GlobalSetup]
         public void Setup()
         {
-            Option<string> fruitOption = new("--fruit");
+            CliOption<string> fruitOption = new("--fruit");
             fruitOption.CompletionSources.Add("apple", "banana", "cherry");
 
-            Option<string> vegetableOption = new("--vegetable");
+            CliOption<string> vegetableOption = new("--vegetable");
             vegetableOption.CompletionSources.Add("asparagus", "broccoli", "carrot");
 
-            var eatCommand = new Command("eat")
+            var eatCommand = new CliCommand("eat")
             {
                 fruitOption,
                 vegetableOption
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
index f51da10836..ac696dcd4b 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
@@ -13,7 +13,7 @@ namespace System.CommandLine.Benchmarks.CommandLine
     public class Perf_Parser_NestedCommands
     {
         private string _testSymbolsAsString;
-        private Command _rootCommand;
+        private CliCommand _rootCommand;
         private CommandLineConfiguration _configuration;
 
         /// <remarks>
@@ -31,7 +31,7 @@ public class Perf_Parser_NestedCommands
         [Params(1, 2, 5)]
         public int TestCommandsDepth;
 
-        private void GenerateTestNestedCommands(Command parent, int depth, int countPerLevel)
+        private void GenerateTestNestedCommands(CliCommand parent, int depth, int countPerLevel)
         {
             if (depth == 0)
                 return;
@@ -39,7 +39,7 @@ private void GenerateTestNestedCommands(Command parent, int depth, int countPerL
             for (int i = 0; i < countPerLevel; i++)
             {
                 string cmdName = $"{parent.Name}_{depth}.{i}";
-                Command cmd = new(cmdName);
+                CliCommand cmd = new(cmdName);
                 parent.Subcommands.Add(cmd);
                 GenerateTestNestedCommands(cmd, depth - 1, countPerLevel);
             }
@@ -49,12 +49,12 @@ private void GenerateTestNestedCommands(Command parent, int depth, int countPerL
         public void SetupRootCommand()
         {
             string rootCommandName = "root";
-            var rootCommand = new Command(rootCommandName);
+            var rootCommand = new CliCommand(rootCommandName);
             _testSymbolsAsString = rootCommandName;
             GenerateTestNestedCommands(rootCommand, TestCommandsDepth, TestCommandsDepth);
 
             // Choose only one path from the commands tree for the test arguments string
-            Command currentCmd = rootCommand;
+            CliCommand currentCmd = rootCommand;
             while (currentCmd is not null && currentCmd.Subcommands.Count > 0)
             {
                 currentCmd = currentCmd.Subcommands[0];
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
index cecf51690c..010ab2c65b 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_Bare.cs
@@ -15,14 +15,14 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Parser_Options_Bare
     {
-        private IEnumerable<Option> _testSymbols;
+        private IEnumerable<CliOption> _testSymbols;
         private string _testSymbolsAsString;
         private CommandLineConfiguration _testConfiguration;
 
-        private IEnumerable<Option> GenerateTestOptions(int count, ArgumentArity arity)
+        private IEnumerable<CliOption> GenerateTestOptions(int count, ArgumentArity arity)
             => Enumerable.Range(0, count)
                          .Select(i =>
-                                     new Option<string>($"-option{i}")
+                                     new CliOption<string>($"-option{i}")
                                      {
                                          Arity = arity,
                                          Description = $"Description for -option {i} ...."
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
index 5cdb9bb9db..17982c2605 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Options_With_Arguments.cs
@@ -18,9 +18,9 @@ public class Perf_Parser_Options_With_Arguments
         private string _testSymbolsAsString;
         private CommandLineConfiguration _configuration;
 
-        private IEnumerable<Option> GenerateTestOptions(int count, ArgumentArity arity)
+        private IEnumerable<CliOption> GenerateTestOptions(int count, ArgumentArity arity)
             => Enumerable.Range(0, count)
-                         .Select(i => new Option<string>($"-option{i}")
+                         .Select(i => new CliOption<string>($"-option{i}")
                              {
                                  Arity = arity,
                                  Description = $"Description for -option {i} ...."
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
index 406025afa2..36474a46b0 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
@@ -3,7 +3,6 @@
 
 using System.Collections.Generic;
 using System.CommandLine.Benchmarks.Helpers;
-using System.CommandLine.Parsing;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -24,11 +23,11 @@ public class Perf_Parser_ParseResult
         public Perf_Parser_ParseResult()
         {
             _output = new StringWriter();
-            var option = new Option<bool>("-opt");
+            var option = new CliOption<bool>("-opt");
 
-            _configuration = new CommandLineConfiguration(new RootCommand { option })
+            _configuration = new CommandLineConfiguration(new CliRootCommand { option })
             {
-                Directives = { new ParseDirective() },
+                Directives = { new ParseDiagramDirective() },
                 Output = _output
             };
         }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs
index 949e59933a..c29f109fef 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_Simple.cs
@@ -21,12 +21,12 @@ public class Perf_Parser_Simple
         [Benchmark]
         public Task<int> MinimalAsync() => BuildMinimalConfig(BuildCommand()).InvokeAsync(Args);
 
-        private static RootCommand BuildCommand()
+        private static CliRootCommand BuildCommand()
         {
-            Option<bool> boolOption = new("--bool", "-b") { Description = "Bool option" };
-            Option<string> stringOption = new("--string", "-s") { Description = "String option" };
+            CliOption<bool> boolOption = new("--bool", "-b") { Description = "Bool option" };
+            CliOption<string> stringOption = new("--string", "-s") { Description = "String option" };
 
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
                 boolOption,
                 stringOption
@@ -41,7 +41,7 @@ private static RootCommand BuildCommand()
             return command;
         }
 
-        private static CommandLineConfiguration BuildMinimalConfig(Command command)
+        private static CommandLineConfiguration BuildMinimalConfig(CliCommand command)
         {
             CommandLineConfiguration config = new(command);
             config.Directives.Clear();
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
index bc9b455409..401233b5a3 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_TypoCorrection.cs
@@ -19,9 +19,9 @@ public class Perf_Parser_TypoCorrection
 
         public Perf_Parser_TypoCorrection()
         {
-            var option = new Option<bool>("--0123456789");
+            var option = new CliOption<bool>("--0123456789");
 
-            _configuration = new CommandLineConfiguration(new RootCommand { option })
+            _configuration = new CommandLineConfiguration(new CliRootCommand { option })
             {
                 EnableTypoCorrections = true,
                 Output = System.IO.TextWriter.Null
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
index d51c247476..9cd3b91fb6 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
@@ -15,7 +15,7 @@ namespace System.CommandLine.Benchmarks.CommandLine
     [BenchmarkCategory(Categories.CommandLine)]
     public class Perf_Suggestions
     {
-        private Option _testSymbol;
+        private CliOption _testSymbol;
         private ParseResult _testParseResult;
 
         /// <remarks>
@@ -27,9 +27,9 @@ private string[] GenerateSuggestionsArray(int count)
                          .Select(i => $"suggestion{i}")
                          .ToArray();
 
-        private IEnumerable<Option> GenerateOptionsArray(int count)
+        private IEnumerable<CliOption> GenerateOptionsArray(int count)
             => Enumerable.Range(0, count)
-                         .Select(i => new Option<string>($"suggestion{i}"));
+                         .Select(i => new CliOption<string>($"suggestion{i}"));
 
         [Params(1, 5, 20, 100)]
         public int TestSuggestionsCount;
@@ -37,7 +37,7 @@ private IEnumerable<Option> GenerateOptionsArray(int count)
         [GlobalSetup(Target = nameof(SuggestionsFromSymbol))]
         public void Setup_FromSymbol()
         {
-            _testSymbol = new Option<string>("--hello");
+            _testSymbol = new CliOption<string>("--hello");
             _testSymbol.CompletionSources.Add(GenerateSuggestionsArray(TestSuggestionsCount));
         }
 
@@ -50,7 +50,7 @@ public void SuggestionsFromSymbol()
         [GlobalSetup(Target = nameof(SuggestionsFromParseResult))]
         public void Setup_FromParseResult()
         {
-            var testCommand = new Command("command");
+            var testCommand = new CliCommand("command");
 
             foreach (var option in GenerateOptionsArray(TestSuggestionsCount))
             {
diff --git a/src/System.CommandLine.Benchmarks/Helpers/Utils.cs b/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
index adac5e4f4c..d1f557eaf7 100644
--- a/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
+++ b/src/System.CommandLine.Benchmarks/Helpers/Utils.cs
@@ -44,9 +44,9 @@ internal static string CreateTestAssemblyInTempFileFromString(string sourceCode,
             return pathToAssemblyFile;
         }
 
-        public static CommandLineConfiguration CreateConfiguration(this IEnumerable<Option> symbols)
+        public static CommandLineConfiguration CreateConfiguration(this IEnumerable<CliOption> symbols)
         {
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             foreach (var symbol in symbols)
             {
diff --git a/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs b/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs
index 901dbb39c1..cc5112d0a8 100644
--- a/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs
+++ b/src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs
@@ -21,12 +21,12 @@ public class ConfigureFromMethodTests
         [Fact]
         public async Task Generated_boolean_parameters_will_accept_zero_arguments()
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_taking_bool)), this);
             config.Output = TextWriter.Null;
 
-            await config.InvokeAsync($"{RootCommand.ExecutableName} --value");
+            await config.InvokeAsync($"{CliRootCommand.ExecutableName} --value");
 
             _receivedValues.Should().BeEquivalentTo(true);
         }
@@ -40,7 +40,7 @@ public async Task Generated_boolean_parameters_will_accept_zero_arguments()
         [InlineData("--value=false", false)]
         public async Task Generated_boolean_parameters_will_accept_one_argument(string commandLine, bool expected)
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_taking_bool)), this);
             config.Output = TextWriter.Null;
@@ -53,7 +53,7 @@ public async Task Generated_boolean_parameters_will_accept_one_argument(string c
         [Fact]
         public async Task Single_character_parameters_generate_aliases_that_accept_a_single_dash_prefix()
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_with_single_letter_parameters)), this);
             config.Output = TextWriter.Null;
@@ -78,7 +78,7 @@ public async Task Single_character_parameters_generate_aliases_that_accept_a_sin
             int minNumberOfValues,
             int maxNumberOfValues)
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName));
 
             var rootCommandArgument = config.RootCommand.Arguments.Single();
@@ -98,7 +98,7 @@ public async Task Single_character_parameters_generate_aliases_that_accept_a_sin
         [InlineData(nameof(Method_having_FileInfo_array_args), "args")]
         public void Parameters_named_arguments_generate_command_arguments_having_the_correct_name(string methodName, string expectedArgName)
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName));
 
             var rootCommandArgument = config.RootCommand.Arguments.Single();
@@ -118,7 +118,7 @@ public void Parameters_named_arguments_generate_command_arguments_having_the_cor
         [InlineData(nameof(Method_having_FileInfo_array_args))]
         public void Options_are_not_generated_for_command_argument_parameters(string methodName)
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName));
 
             var rootCommand = config.RootCommand;
@@ -147,7 +147,7 @@ public void Options_are_not_generated_for_command_argument_parameters(string met
             string methodName,
             Type expectedType)
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(GetMethodInfo(methodName));
 
             var rootCommandArgument = config.RootCommand.Arguments.Single();
@@ -160,7 +160,7 @@ public void Options_are_not_generated_for_command_argument_parameters(string met
         [Fact]
         public async Task When_method_returns_void_then_return_code_is_0()
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_returning_void)), this);
             config.Output = TextWriter.Null;
@@ -173,7 +173,7 @@ public async Task When_method_returns_void_then_return_code_is_0()
         [Fact]
         public async Task When_method_returns_int_then_return_code_is_set_to_return_value()
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_returning_int)), this);
             config.Output = TextWriter.Null;
@@ -186,7 +186,7 @@ public async Task When_method_returns_int_then_return_code_is_set_to_return_valu
         [Fact]
         public async Task When_method_returns_Task_of_int_then_return_code_is_set_to_return_value()
         {
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                          .ConfigureRootCommandFromMethod(
                              GetMethodInfo(nameof(Method_returning_Task_of_int)), this);
             config.Output = TextWriter.Null;
@@ -209,13 +209,13 @@ public void Options_are_not_built_for_infrastructure_types_exposed_by_method_par
             var options = handlerMethod.BuildOptions();
 
             options.Should()
-                   .NotContain(o => o.GetType().IsAssignableTo(typeof(Option<>).MakeGenericType(type)));
+                   .NotContain(o => o.GetType().IsAssignableTo(typeof(CliOption<>).MakeGenericType(type)));
         }
 
         [Fact]
         public async Task Method_parameters_on_the_invoked_member_method_are_bound_to_matching_option_names_by_MethodInfo_with_target()
         {
-            var command = new Command("test");
+            var command = new CliCommand("test");
             command.ConfigureFromMethod(GetMethodInfo(nameof(Method_taking_bool)), this);
 
             await command.Parse("--value").InvokeAsync();
@@ -226,7 +226,7 @@ public async Task Method_parameters_on_the_invoked_member_method_are_bound_to_ma
         [Fact]
         public async Task Method_with_multiple_parameters_with_default_values_are_resolved_correctly()
         {
-            var command = new Command("test");
+            var command = new CliCommand("test");
             command.ConfigureFromMethod(GetMethodInfo(nameof(Method_with_multiple_default_values)), this);
 
             await command.Parse("").InvokeAsync();
diff --git a/src/System.CommandLine.DragonFruit/CommandLine.cs b/src/System.CommandLine.DragonFruit/CommandLine.cs
index 01387118e8..c5eb2eacae 100644
--- a/src/System.CommandLine.DragonFruit/CommandLine.cs
+++ b/src/System.CommandLine.DragonFruit/CommandLine.cs
@@ -106,7 +106,7 @@ public static class CommandLine
             string xmlDocsFilePath,
             object target)
         {
-            return new CommandLineConfiguration(new RootCommand())
+            return new CommandLineConfiguration(new CliRootCommand())
                 .ConfigureRootCommandFromMethod(method, target)
                 .ConfigureHelpFromXmlComments(method, xmlDocsFilePath);
         }
@@ -139,7 +139,7 @@ public static class CommandLine
         };
 
         public static void ConfigureFromMethod(
-            this Command command,
+            this CliCommand command,
             MethodInfo method,
             object target = null)
         {
@@ -243,7 +243,7 @@ internal static string BuildAlias(string parameterName)
                        : $"-{parameterName.ToLowerInvariant()}";
         }
 
-        public static IEnumerable<Option> BuildOptions(this MethodInfo method)
+        public static IEnumerable<CliOption> BuildOptions(this MethodInfo method)
         {
             var descriptor = HandlerDescriptor.FromMethodInfo(method);
 
@@ -264,7 +264,7 @@ public static IEnumerable<Option> BuildOptions(this MethodInfo method)
             }
         }
 
-        public static Option BuildOption(this ParameterDescriptor parameter)
+        public static CliOption BuildOption(this ParameterDescriptor parameter)
             => OptionBuilder.CreateOption(
                 parameter.BuildAlias(),
                 parameter.ValueType,
@@ -300,7 +300,7 @@ private static string GetDefaultXmlDocsFileLocation(Assembly assembly)
         /// </summary>
         /// <param name="alias">The alias, which can include a prefix.</param>
         /// <returns><see langword="true"/> if the alias exists; otherwise, <see langword="false"/>.</returns>
-        private static bool HasAliasIgnoringPrefix(Option option, string alias)
+        private static bool HasAliasIgnoringPrefix(CliOption option, string alias)
         {
             ReadOnlySpan<char> rawAlias = alias.AsSpan(GetPrefixLength(alias));
 
diff --git a/src/System.CommandLine.Generator.CommandHandler/CommandExtensions.cs b/src/System.CommandLine.Generator.CommandHandler/CommandExtensions.cs
index f972403650..4ee925c5bf 100644
--- a/src/System.CommandLine.Generator.CommandHandler/CommandExtensions.cs
+++ b/src/System.CommandLine.Generator.CommandHandler/CommandExtensions.cs
@@ -1,7 +1,7 @@
 namespace System.CommandLine;
 
 /// <summary>
-/// Provides extension methods for <see cref="Command" />.
+/// Provides extension methods for <see cref="CliCommand" />.
 /// </summary>
 public static class CommandExtensions
 {
@@ -16,9 +16,9 @@ public static class CommandExtensions
     /// <param name="delegate">A delegate implementing the handler for the command.</param>
     /// <param name="symbols">The symbols used to bind the handler's parameters.</param>
     public static void SetHandler<TDelegate>(
-        this Command command,
+        this CliCommand command,
         TDelegate @delegate,
-        params Symbol[] symbols)
+        params CliSymbol[] symbols)
     {
         throw new InvalidOperationException(_messageForWhenGeneratorIsNotInUse);
     }
diff --git a/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs b/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs
index 1b92774a6b..20af68db54 100644
--- a/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs
+++ b/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs
@@ -21,10 +21,10 @@ void Execute(string fullnameOrNickname, int age)
                 boundAge = age;
             }
 
-            var nameArgument = new Argument<string>("arg");
-            var ageOption = new Option<int>("--age");
+            var nameArgument = new CliArgument<string>("arg");
+            var ageOption = new CliOption<int>("--age");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 nameArgument,
                 ageOption
@@ -45,10 +45,10 @@ public async Task Can_generate_handler_for_void_returning_delegate()
             string? boundName = default;
             int boundAge = default;
 
-            var nameArgument = new Argument<string>("arg");
-            var ageOption = new Option<int>("--age");
+            var nameArgument = new CliArgument<string>("arg");
+            var ageOption = new CliOption<int>("--age");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 nameArgument,
                 ageOption
@@ -79,10 +79,10 @@ void Execute(Character character)
                 boundAge = character.Age;
             }
 
-            var command = new Command("command");
-            var nameOption = new Option<string>("--name");
+            var command = new CliCommand("command");
+            var nameOption = new CliOption<string>("--name");
             command.Options.Add(nameOption);
-            var ageOption = new Option<int>("--age");
+            var ageOption = new CliOption<int>("--age");
             command.Options.Add(ageOption);
 
             command.SetHandler<Action<Character>>(Execute, nameOption, ageOption);
@@ -101,10 +101,10 @@ int Execute(int first, int second)
                 return first + second;
             }
 
-            var command = new Command("add");
-            var firstArgument = new Argument<int>("first");
+            var command = new CliCommand("add");
+            var firstArgument = new CliArgument<int>("first");
             command.Arguments.Add(firstArgument);
-            var secondArgument = new Argument<int>("second");
+            var secondArgument = new CliArgument<int>("second");
             command.Arguments.Add(secondArgument);
 
             command.SetHandler<Func<int, int, int>>(Execute, firstArgument, secondArgument);
@@ -125,7 +125,7 @@ public async Task Can_generate_handler_with_well_know_parameters_types()
                 boundParseResult = parseResult;
             }
 
-            var command = new Command("command");
+            var command = new CliCommand("command");
 
             command.SetHandler<Action<ParseResult>>(Execute);
 
@@ -147,10 +147,10 @@ async Task ExecuteAsync(string fullnameOrNickname, int age)
                 boundAge = age;
             }
 
-            var nameArgument = new Argument<string>("arg");
-            var ageOption = new Option<int>("--age");
+            var nameArgument = new CliArgument<string>("arg");
+            var ageOption = new CliOption<int>("--age");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 nameArgument,
                 ageOption
@@ -174,9 +174,9 @@ async Task<int> Execute(int first, int second)
                 return first + second;
             }
 
-            var firstArgument = new Argument<int>("first");
-            var secondArgument = new Argument<int>("second");
-            var command = new Command("add")
+            var firstArgument = new CliArgument<int>("first");
+            var secondArgument = new CliArgument<int>("second");
+            var command = new CliCommand("add")
             {
                 firstArgument,
                 secondArgument
@@ -207,13 +207,13 @@ void Execute2(string value)
                 secondValue = value;
             }
 
-            var command1 = new Command("first");
-            var argument1 = new Argument<string>("first-value");
+            var command1 = new CliCommand("first");
+            var argument1 = new CliArgument<string>("first-value");
             command1.Arguments.Add(argument1);
             command1.SetHandler<Action<string>>(Execute1, argument1);
 
-            var command2 = new Command("second");
-            var argument2 = new Argument<string>("second-value");
+            var command2 = new CliCommand("second");
+            var argument2 = new CliArgument<string>("second-value");
             command2.Arguments.Add(argument2);
             command2.SetHandler<Action<string>>(Execute2, argument2);
 
@@ -236,10 +236,10 @@ void Execute(string fullnameOrNickname, int age)
                 boundAge = age;
             }
 
-            var nameArgument = new Argument<string>("arg");
-            var ageOption = new Option<int>("--age");
+            var nameArgument = new CliArgument<string>("arg");
+            var ageOption = new CliOption<int>("--age");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 nameArgument,
                 ageOption
@@ -259,10 +259,10 @@ public async Task Can_generate_handler_for_lambda()
             string? boundName = default;
             int boundAge = default;
 
-            var nameArgument = new Argument<string>("arg");
-            var ageOption = new Option<int>("--age");
+            var nameArgument = new CliArgument<string>("arg");
+            var ageOption = new CliOption<int>("--age");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 nameArgument,
                 ageOption
@@ -286,10 +286,10 @@ public async Task Can_generate_handler_for_lambda_wth_return_type_specified()
             string? boundName = default;
             int boundAge = default;
 
-            var nameArgument = new Argument<string>("arg");
-            var ageOption = new Option<int>("--age");
+            var nameArgument = new CliArgument<string>("arg");
+            var ageOption = new CliOption<int>("--age");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 nameArgument,
                 ageOption
diff --git a/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs b/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs
index 9ae463b9de..378c107267 100644
--- a/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs
+++ b/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs
@@ -151,7 +151,7 @@ private static (string Type, string Name)[] GetMethodParameters(DelegateInvocati
                 builder.Append($"<{string.Join(", ", Enumerable.Range(1, invocation.NumberOfGenerericParameters).Select(x => $@"T{x}"))}>");
             }
             builder.Append(@$"(
-            this global::System.CommandLine.Command command,");
+            this global::System.CommandLine.CliCommand command,");
 
             builder.Append($@"
             {invocation.DelegateType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)} method");
diff --git a/src/System.CommandLine.Generator/SyntaxReceiver.cs b/src/System.CommandLine.Generator/SyntaxReceiver.cs
index 3f35373e41..bf025a51a0 100644
--- a/src/System.CommandLine.Generator/SyntaxReceiver.cs
+++ b/src/System.CommandLine.Generator/SyntaxReceiver.cs
@@ -12,7 +12,7 @@ namespace System.CommandLine.Generator
 {
     internal class SyntaxReceiver : ISyntaxContextReceiver
     {
-        private static readonly string _nameOfExtensionMethodAnchorType = "global::System.CommandLine.Command";
+        private static readonly string _nameOfExtensionMethodAnchorType = "global::System.CommandLine.CliCommand";
 
         public HashSet<DelegateInvocation> Invocations { get; } = new();
 
@@ -183,12 +183,12 @@ Parameter FromNamedTypeSymbol(INamedTypeSymbol namedTypeSymbol)
             {
                 if (namedTypeSymbol.TypeArguments.Length > 0)
                 {
-                    if (namedTypeSymbol.Name == "Option")
+                    if (namedTypeSymbol.Name == "CliOption")
                     {
                         return new OptionParameter(localName, namedTypeSymbol, namedTypeSymbol.TypeArguments[0]);
                     }
 
-                    if (namedTypeSymbol.Name == "Argument")
+                    if (namedTypeSymbol.Name == "CliArgument")
                     {
                         return new ArgumentParameter(localName, namedTypeSymbol, namedTypeSymbol.TypeArguments[0]);
                     }
diff --git a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
index b21bf35c17..16ef51e3ca 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
@@ -50,7 +50,7 @@ public static async Task Parameter_is_available_in_property()
         [Fact]
         public static async Task Can_have_different_handlers_based_on_command()
         {
-            var root = new RootCommand();
+            var root = new CliRootCommand();
 
             root.Subcommands.Add(new MyCommand().UseCommandHandler<MyCommand.MyHandler>());
             root.Subcommands.Add(new MyOtherCommand().UseCommandHandler<MyOtherCommand.MyHandler>());
@@ -79,7 +79,7 @@ public static async Task Can_have_different_handlers_based_on_command()
         public static async Task Can_bind_to_arguments_via_injection()
         {
             var service = new MyService();
-            var cmd = new RootCommand();
+            var cmd = new CliRootCommand();
             cmd.Subcommands.Add(new MyOtherCommand().UseCommandHandler<MyOtherCommand.MyHandler>());
             var config = new CommandLineConfiguration(cmd)
                 .UseHost(host =>
@@ -100,7 +100,7 @@ public static async Task Invokes_DerivedClass()
         {
             var service = new MyService();
 
-            var cmd = new RootCommand();
+            var cmd = new CliRootCommand();
             cmd.Subcommands.Add(new MyCommand().UseCommandHandler<MyCommand.MyDerivedHandler>());
             cmd.Subcommands.Add(new MyOtherCommand().UseCommandHandler<MyOtherCommand.MyDerivedHandler>());
             var config = new CommandLineConfiguration(cmd)
@@ -135,11 +135,11 @@ public override Task<int> InvokeAsync(ParseResult context, CancellationToken can
             protected abstract int Act();
         }
 
-        public class MyCommand : Command
+        public class MyCommand : CliCommand
         {
             public MyCommand() : base(name: "mycommand")
             {
-                Options.Add(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
+                Options.Add(new CliOption<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
             }
 
             public class MyHandler : CliAction
@@ -183,12 +183,12 @@ protected override int Act()
             }
         }
 
-        public class MyOtherCommand : Command
+        public class MyOtherCommand : CliCommand
         {
             public MyOtherCommand() : base(name: "myothercommand")
             {
-                Options.Add(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
-                Arguments.Add(new Argument<string>("One") {  Arity = ArgumentArity.ZeroOrOne });
+                Options.Add(new CliOption<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
+                Arguments.Add(new CliArgument<string>("One") {  Arity = ArgumentArity.ZeroOrOne });
             }
 
             public class MyHandler : CliAction
diff --git a/src/System.CommandLine.Hosting.Tests/HostingTests.cs b/src/System.CommandLine.Hosting.Tests/HostingTests.cs
index 26a0771b40..52ce95c366 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingTests.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingTests.cs
@@ -27,7 +27,7 @@ void Execute(IHost host)
             }
 
             var config = new CommandLineConfiguration(
-                new RootCommand { Action = CommandHandler.Create<IHost>(Execute) }
+                new CliRootCommand { Action = CommandHandler.Create<IHost>(Execute) }
                 )
                 .UseHost();
 
@@ -41,7 +41,7 @@ public async static Task UseHost_adds_ParseResult_to_HostBuilder_Properties()
         {
             ParseResult parseResult = null;
 
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                 .UseHost(host =>
                 {
                     if (host.Properties.TryGetValue(typeof(ParseResult), out var ctx))
@@ -67,7 +67,7 @@ void Execute(IHost host)
             }
 
             var config = new CommandLineConfiguration(
-                new RootCommand { Action = CommandHandler.Create<IHost>(Execute) }
+                new CliRootCommand { Action = CommandHandler.Create<IHost>(Execute) }
                 )
                 .UseHost();
 
@@ -93,7 +93,7 @@ void Execute(IHost host)
             }
 
             var config = new CommandLineConfiguration(
-                new RootCommand
+                new CliRootCommand
                 {
                     Action = CommandHandler.Create<IHost>(Execute),
                 })
@@ -128,7 +128,7 @@ void Execute(IHost host)
             }
 
             var config = new CommandLineConfiguration(
-                new RootCommand
+                new CliRootCommand
                 {
                     Action = CommandHandler.Create<IHost>(Execute),
                 })
@@ -165,7 +165,7 @@ void Execute(IHost host)
             }
 
             var config = new CommandLineConfiguration(
-                new RootCommand
+                new CliRootCommand
                 {
                     Action = CommandHandler.Create<IHost>(Execute)
                 })
@@ -183,8 +183,8 @@ public static void UseHost_binds_parsed_arguments_to_options()
             string commandLine = $"-{nameof(MyOptions.MyArgument)} {myValue}";
             MyOptions options = null;
 
-            var rootCmd = new RootCommand();
-            rootCmd.Options.Add(new Option<int>($"-{nameof(MyOptions.MyArgument)}"));
+            var rootCmd = new CliRootCommand();
+            rootCmd.Options.Add(new CliOption<int>($"-{nameof(MyOptions.MyArgument)}"));
             rootCmd.Action = CommandHandler.Create((IHost host) =>
             {
                 options = host.Services
@@ -241,7 +241,7 @@ public void SubCommand(int myArgument)
         public async static Task GetParseResult_returns_non_null_instance()
         {
             bool ctxAsserted = false;
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                 .UseHost(hostBuilder =>
                 {
                     ParseResult ctx = hostBuilder.GetParseResult();
@@ -257,7 +257,7 @@ public async static Task GetParseResult_returns_non_null_instance()
         public async static Task GetParseResult_in_ConfigureServices_returns_non_null_instance()
         {
             bool ctxAsserted = false;
-            var config = new CommandLineConfiguration(new RootCommand())
+            var config = new CommandLineConfiguration(new CliRootCommand())
                 .UseHost(hostBuilder =>
                 {
                     hostBuilder.ConfigureServices((hostingCtx, services) =>
diff --git a/src/System.CommandLine.Hosting/DirectiveConfigurationExtensions.cs b/src/System.CommandLine.Hosting/DirectiveConfigurationExtensions.cs
index 4a9238af71..eb9f717420 100644
--- a/src/System.CommandLine.Hosting/DirectiveConfigurationExtensions.cs
+++ b/src/System.CommandLine.Hosting/DirectiveConfigurationExtensions.cs
@@ -10,7 +10,7 @@ public static class DirectiveConfigurationExtensions
     {
         public static IConfigurationBuilder AddCommandLineDirectives(
             this IConfigurationBuilder config, ParseResult commandline,
-            Directive directive)
+            CliDirective directive)
         {
             if (commandline is null)
                 throw new ArgumentNullException(nameof(commandline));
diff --git a/src/System.CommandLine.Hosting/HostingAction.cs b/src/System.CommandLine.Hosting/HostingAction.cs
index 75cb580904..489cf8c3b4 100644
--- a/src/System.CommandLine.Hosting/HostingAction.cs
+++ b/src/System.CommandLine.Hosting/HostingAction.cs
@@ -15,12 +15,12 @@ internal sealed class HostingAction : BindingHandler
         private readonly Action<IHostBuilder> _configureHost;
         private readonly CliAction _actualAction;
 
-        internal static void SetHandlers(Command command, Func<string[], IHostBuilder> hostBuilderFactory, Action<IHostBuilder> configureHost)
+        internal static void SetHandlers(CliCommand command, Func<string[], IHostBuilder> hostBuilderFactory, Action<IHostBuilder> configureHost)
         {
             command.Action = new HostingAction(hostBuilderFactory, configureHost, command.Action);
             command.TreatUnmatchedTokensAsErrors = false; // to pass unmatched Tokens to host builder factory
 
-            foreach (Command subCommand in command.Subcommands)
+            foreach (CliCommand subCommand in command.Subcommands)
             {
                 SetHandlers(subCommand, hostBuilderFactory, configureHost);
             }
@@ -45,7 +45,7 @@ public async override Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
                 ?? new HostBuilder();
             hostBuilder.Properties[typeof(ParseResult)] = parseResult;
 
-            Directive configurationDirective = parseResult.Configuration.Directives.Single(d => d.Name == "config");
+            CliDirective configurationDirective = parseResult.Configuration.Directives.Single(d => d.Name == "config");
             hostBuilder.ConfigureHostConfiguration(config =>
             {
                 config.AddCommandLineDirectives(parseResult, configurationDirective);
diff --git a/src/System.CommandLine.Hosting/HostingExtensions.cs b/src/System.CommandLine.Hosting/HostingExtensions.cs
index 50fa4dc29f..1d0942e7b4 100644
--- a/src/System.CommandLine.Hosting/HostingExtensions.cs
+++ b/src/System.CommandLine.Hosting/HostingExtensions.cs
@@ -14,7 +14,7 @@ public static class HostingExtensions
             Func<string[], IHostBuilder> hostBuilderFactory,
             Action<IHostBuilder> configureHost = null)
         {
-            builder.Directives.Add(new Directive("config"));
+            builder.Directives.Add(new CliDirective("config"));
 
             HostingAction.SetHandlers(builder.RootCommand, hostBuilderFactory, configureHost);
 
@@ -51,7 +51,7 @@ public static IHostBuilder UseInvocationLifetime(this IHostBuilder host, Action<
             });
         }
 
-        public static Command UseCommandHandler<THandler>(this Command command)
+        public static CliCommand UseCommandHandler<THandler>(this CliCommand command)
             where THandler : CliAction
         {
             command.Action = CommandHandler.Create(typeof(THandler).GetMethod(nameof(CliAction.InvokeAsync)));
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
index 5227b54be1..3234480aea 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
@@ -27,7 +27,7 @@ public class ModelBinderTests
         var targetType = typeof(ClassWithCtorParameter<>).MakeGenericType(type);
         var binder = new ModelBinder(targetType);
 
-        var command = new Command("the-command")
+        var command = new CliCommand("the-command")
         {
             OptionBuilder.CreateOption("--value", type)
         };
@@ -54,7 +54,7 @@ public class ModelBinderTests
         var targetType = typeof(ClassWithCtorParameter<>).MakeGenericType(type);
         var binder = new ModelBinder(targetType);
 
-        var command = new Command("the-command")
+        var command = new CliCommand("the-command")
         {
             ArgumentBuilder.CreateArgument(type)
         };
@@ -77,7 +77,7 @@ public class ModelBinderTests
         var targetType = typeof(ClassWithCtorParameter<>).MakeGenericType(type);
         var binder = new ModelBinder(targetType);
 
-        var command = new Command("the-command")
+        var command = new CliCommand("the-command")
         {
             ArgumentBuilder.CreateArgument(type)
         };
@@ -97,12 +97,12 @@ public class ModelBinderTests
     [Fact]
     public void Explicitly_configured_default_values_can_be_bound_by_name_to_constructor_parameters()
     {
-        var option = new Option<string>("--string-option")
+        var option = new CliOption<string>("--string-option")
         {
             DefaultValueFactory = (_) => "the default",
         };
 
-        var command = new Command("the-command");
+        var command = new CliCommand("the-command");
         command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithMultiLetterCtorParameters));
 
@@ -126,7 +126,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_constru
         var targetType = typeof(ClassWithSetter<>).MakeGenericType(type);
         var binder = new ModelBinder(targetType);
 
-        var command = new Command("the-command")
+        var command = new CliCommand("the-command")
         {
             OptionBuilder.CreateOption("--value", type)
         };
@@ -153,7 +153,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_constru
         var targetType = typeof(ClassWithSetter<>).MakeGenericType(type);
         var binder = new ModelBinder(targetType);
 
-        var command = new Command("the-command")
+        var command = new CliCommand("the-command")
         {
             ArgumentBuilder.CreateArgument(type)
         };
@@ -172,9 +172,9 @@ public void Types_having_constructors_accepting_a_single_string_are_bound_using_
     {
         var tempPath = Path.GetTempPath();
 
-        var option = new Option<DirectoryInfo>("--value");
+        var option = new CliOption<DirectoryInfo>("--value");
 
-        var command = new Command("the-command");
+        var command = new CliCommand("the-command");
         command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithCtorParameter<DirectoryInfo>));
         var bindingContext = command.Parse($"--value \"{tempPath}\"").GetBindingContext();
@@ -187,9 +187,9 @@ public void Types_having_constructors_accepting_a_single_string_are_bound_using_
     [Fact]
     public void Explicitly_configured_default_values_can_be_bound_by_name_to_property_setters()
     {
-        var option = new Option<string>("--value") { DefaultValueFactory = (_) => "the default" };
+        var option = new CliOption<string>("--value") { DefaultValueFactory = (_) => "the default" };
 
-        var command = new Command("the-command");
+        var command = new CliCommand("the-command");
         command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithSetter<string>));
 
@@ -203,9 +203,9 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_propert
     [Fact]
     public void Property_setters_with_no_default_value_and_no_matching_option_are_not_called()
     {
-        var command = new Command("the-command")
+        var command = new CliCommand("the-command")
         {
-            new Option<string>("--string-option")
+            new CliOption<string>("--string-option")
         };
 
         var binder = new ModelBinder(typeof(ClassWithSettersAndCtorParametersWithDifferentNames));
@@ -220,9 +220,9 @@ public void Property_setters_with_no_default_value_and_no_matching_option_are_no
     [Fact]
     public void Parse_result_can_be_used_to_create_an_instance_without_doing_handler_invocation()
     {
-        Command command = new ("the-command")
+        CliCommand command = new ("the-command")
         {
-            new Option<int>("--int-option")
+            new CliOption<int>("--int-option")
         };
         var bindingContext = command.Parse("the-command --int-option 123").GetBindingContext();
         var binder = new ModelBinder(typeof(ClassWithMultiLetterSetters));
@@ -235,9 +235,9 @@ public void Parse_result_can_be_used_to_create_an_instance_without_doing_handler
     [Fact]
     public void Parse_result_can_be_used_to_modify_an_existing_instance_without_doing_handler_invocation()
     {
-        Command command = new("the-command")
+        CliCommand command = new("the-command")
         {
-            new Option<int>("--int-option")
+            new CliOption<int>("--int-option")
         };
         var instance = new ClassWithMultiLetterSetters();
         var bindingContext = command.Parse("the-command --int-option 123").GetBindingContext();
@@ -251,7 +251,7 @@ public void Parse_result_can_be_used_to_modify_an_existing_instance_without_doin
     [Fact]
     public void Modify_an_existing_instance_should_keep_all_default_values_if_no_argument_matches_option()
     {
-        Command parser = new ("the-command");
+        CliCommand parser = new ("the-command");
 
         var instance = new ClassWithComplexTypes();
         var bindingContext = parser.Parse("the-command").GetBindingContext();
@@ -265,10 +265,10 @@ public void Modify_an_existing_instance_should_keep_all_default_values_if_no_arg
     [Fact]
     public void Values_from_options_on_parent_commands_are_bound_by_name_by_default()
     {
-        var parentCommand = new Command("parent-command")
+        var parentCommand = new CliCommand("parent-command")
         {
-            new Option<int>("--int-option"),
-            new Command("child-command")
+            new CliOption<int>("--int-option"),
+            new CliCommand("child-command")
         };
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
@@ -285,13 +285,13 @@ public void Values_from_options_on_parent_commands_are_bound_by_name_by_default(
     [Fact]
     public void Default_values_from_options_on_parent_commands_are_bound_by_name_by_default()
     {
-        var parentCommand = new Command("parent-command")
+        var parentCommand = new CliCommand("parent-command")
         {
-            new Option<int>("--int-option")
+            new CliOption<int>("--int-option")
             { 
                 DefaultValueFactory = (_) => 123,
             },
-            new Command("child-command")
+            new CliCommand("child-command")
         };
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
@@ -308,10 +308,10 @@ public void Default_values_from_options_on_parent_commands_are_bound_by_name_by_
     [Fact]
     public void Values_from_parent_command_arguments_are_bound_by_name_by_default()
     {
-        var parentCommand = new Command("parent-command")
+        var parentCommand = new CliCommand("parent-command")
         {
-            new Argument<int>(nameof(ClassWithMultiLetterSetters.IntOption)),
-            new Command("child-command")
+            new CliArgument<int>(nameof(ClassWithMultiLetterSetters.IntOption)),
+            new CliCommand("child-command")
         };
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
@@ -328,13 +328,13 @@ public void Values_from_parent_command_arguments_are_bound_by_name_by_default()
     [Fact]
     public void Default_values_from_parent_command_arguments_are_bound_by_name_by_default()
     {
-        var parentCommand = new Command("parent-command")
+        var parentCommand = new CliCommand("parent-command")
         {
-            new Argument<int>(nameof(ClassWithMultiLetterSetters.IntOption))
+            new CliArgument<int>(nameof(ClassWithMultiLetterSetters.IntOption))
             {
                 DefaultValueFactory = (_) => 123
             },
-            new Command("child-command")
+            new CliCommand("child-command")
         };
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
@@ -351,9 +351,9 @@ public void Default_values_from_parent_command_arguments_are_bound_by_name_by_de
     [Fact]
     public void Values_from_options_on_parent_commands_can_be_bound_regardless_of_naming()
     {
-        var childCommand = new Command("child-command");
-        var option = new Option<int>("-x");
-        var parentCommand = new Command("parent-command")
+        var childCommand = new CliCommand("child-command");
+        var option = new CliOption<int>("-x");
+        var parentCommand = new CliCommand("parent-command")
         {
             option,
             childCommand
@@ -375,7 +375,7 @@ public void Values_from_options_on_parent_commands_can_be_bound_regardless_of_na
     [Fact]
     public void Arbitrary_values_can_be_bound()
     {
-        var command = new Command("the-command");
+        var command = new CliCommand("the-command");
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
 
@@ -393,8 +393,8 @@ public void Arbitrary_values_can_be_bound()
     [Fact]
     public void PropertyInfo_can_be_bound_to_option()
     {
-        var command = new Command("the-command");
-        var option = new Option<int>("--fred");
+        var command = new CliCommand("the-command");
+        var option = new CliOption<int>("--fred");
         command.Add(option);
 
         var type = typeof(ClassWithMultiLetterSetters);
@@ -415,8 +415,8 @@ public void PropertyInfo_can_be_bound_to_option()
     [Fact]
     public void PropertyInfo_can_be_bound_to_argument()
     {
-        var command = new Command("the-command");
-        var argument = new Argument<int>("arg") { Arity = ArgumentArity.ExactlyOne };
+        var command = new CliCommand("the-command");
+        var argument = new CliArgument<int>("arg") { Arity = ArgumentArity.ExactlyOne };
         command.Arguments.Add(argument);
 
         var type = typeof(ClassWithMultiLetterSetters);
@@ -435,8 +435,8 @@ public void PropertyInfo_can_be_bound_to_argument()
     [Fact]
     public void PropertyExpression_can_be_bound_to_option()
     {
-        var command = new Command("the-command");
-        var option = new Option<int>("--fred");
+        var command = new CliCommand("the-command");
+        var option = new CliOption<int>("--fred");
         command.Options.Add(option);
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
@@ -455,8 +455,8 @@ public void PropertyExpression_can_be_bound_to_option()
     [Fact]
     public void PropertyExpression_can_be_bound_to_argument()
     {
-        var command = new Command("the-command");
-        var argument = new Argument<int>("arg") { Arity = ArgumentArity.ExactlyOne };
+        var command = new CliCommand("the-command");
+        var argument = new CliArgument<int>("arg") { Arity = ArgumentArity.ExactlyOne };
         command.Arguments.Add(argument);
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
@@ -475,9 +475,9 @@ public void PropertyExpression_can_be_bound_to_argument()
     [Fact]
     public void Option_argument_is_bound_to_longest_constructor()
     {
-        var option = new Option<int>("--int-property");
+        var option = new CliOption<int>("--int-property");
 
-        var bindingContext = new RootCommand { option }.Parse("--int-property 42").GetBindingContext();
+        var bindingContext = new CliRootCommand { option }.Parse("--int-property 42").GetBindingContext();
         var binder = new ModelBinder<ClassWithMultipleCtor>();
         var instance = binder.CreateInstance(bindingContext) as ClassWithMultipleCtor;
 
@@ -488,8 +488,8 @@ public void Option_argument_is_bound_to_longest_constructor()
     [Fact]
     public void Command_argument_is_bound_to_longest_constructor()
     {
-        var rootCommand = new RootCommand();
-        rootCommand.Arguments.Add(new Argument<int>(nameof(ClassWithMultipleCtor.IntProperty)));
+        var rootCommand = new CliRootCommand();
+        rootCommand.Arguments.Add(new CliArgument<int>(nameof(ClassWithMultipleCtor.IntProperty)));
 
         var bindingContext = rootCommand.Parse("42").GetBindingContext();
         var binder = new ModelBinder<ClassWithMultipleCtor>();
@@ -502,9 +502,9 @@ public void Command_argument_is_bound_to_longest_constructor()
     [Fact]
     public void Explicit_model_binder_binds_only_to_configured_properties()
     {
-        var intOption = new Option<int>("--int-property");
-        var stringOption = new Option<string>("--string-property");
-        RootCommand rootCommand = new RootCommand { intOption, stringOption };
+        var intOption = new CliOption<int>("--int-property");
+        var stringOption = new CliOption<string>("--string-property");
+        CliRootCommand rootCommand = new CliRootCommand { intOption, stringOption };
 
         var bindingContext = rootCommand.Parse("--int-property 42 --string-property Hello").GetBindingContext();
         var binder = new ModelBinder<ClassWithMultiLetterSetters>
@@ -522,9 +522,9 @@ public void Explicit_model_binder_binds_only_to_configured_properties()
     [Fact]
     public async Task Bound_array_command_arguments_default_to_an_empty_array_when_not_specified()
     {
-        var rootCommand = new RootCommand("Command")
+        var rootCommand = new CliRootCommand("Command")
         {
-            new Argument<string[]>("names")
+            new CliArgument<string[]>("names")
         };
         rootCommand.Action = CommandHandler.Create<string[]>(Handler);
         string[] passedNames = null;
@@ -542,9 +542,9 @@ int Handler(string[] names)
     [Fact]
     public async Task Bound_enumerable_command_arguments_default_to_an_empty_array_when_not_specified()
     {
-        var rootCommand = new RootCommand("Command")
+        var rootCommand = new CliRootCommand("Command")
         {
-            new Argument<IEnumerable<string>>("names")
+            new CliArgument<IEnumerable<string>>("names")
         };
         rootCommand.Action = CommandHandler.Create<IEnumerable<string>>(Handler);
         IEnumerable<string> passedNames = null;
@@ -562,9 +562,9 @@ int Handler(IEnumerable<string> names)
     [Fact]
     public async Task Bound_array_options_default_to_an_empty_array_when_not_specified()
     {
-        var rootCommand = new RootCommand("Command")
+        var rootCommand = new CliRootCommand("Command")
         {
-            new Option<string[]>("--names")
+            new CliOption<string[]>("--names")
         };
         rootCommand.Action = CommandHandler.Create<string[]>(Handler);
         string[] passedNames = null;
@@ -582,9 +582,9 @@ int Handler(string[] names)
     [Fact]
     public async Task Bound_enumerable_options_default_to_an_empty_array_when_not_specified()
     {
-        var rootCommand = new RootCommand("Command")
+        var rootCommand = new CliRootCommand("Command")
         {
-            new Option<IEnumerable<string>>("--names"),
+            new CliOption<IEnumerable<string>>("--names"),
         };
         rootCommand.Action = CommandHandler.Create<IEnumerable<string>>(Handler);
         IEnumerable<string> passedNames = null;
@@ -604,10 +604,10 @@ public void Default_values_from_options_with_the_same_type_are_bound_and_use_the
     {
         int first = 0, second = 0;
 
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
-            new Option<int>("one") { DefaultValueFactory = (_) => 1 },
-            new Option<int>("two") { DefaultValueFactory = (_) => 2 }
+            new CliOption<int>("one") { DefaultValueFactory = (_) => 1 },
+            new CliOption<int>("two") { DefaultValueFactory = (_) => 2 }
         };
         rootCommand.Action = CommandHandler.Create<int, int>((one, two) =>
         {
@@ -626,9 +626,9 @@ public void Default_values_from_options_with_the_same_type_are_bound_and_use_the
     [Fact]
     public void Binder_does_not_match_on_partial_name()
     {
-        var command = new RootCommand
+        var command = new CliRootCommand
         {
-            new Option<List<string>>("--abc")
+            new CliOption<List<string>>("--abc")
         };
 
         ClassWithOnePropertyNameThatIsSubstringOfAnother boundValue = default;
@@ -652,7 +652,7 @@ public async Task Empty_input_is_bound_correctly_to_list_type_properties()
     {
         ClassWithListTypePropertiesAndDefaultCtor boundInstance = default;
 
-        var cmd = new RootCommand
+        var cmd = new CliRootCommand
         {
             Action = CommandHandler.Create((ClassWithListTypePropertiesAndDefaultCtor value) => { boundInstance = value; })
         };
@@ -669,9 +669,9 @@ public async Task Decimals_are_bound_correctly_when_no_token_is_matched()
     {
         decimal? receivedValue = null;
 
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
-            new Option<decimal>("--opt-decimal")
+            new CliOption<decimal>("--opt-decimal")
         };
         rootCommand.Action = CommandHandler.Create((ComplexType options) => { receivedValue = options.OptDecimal; });
 
@@ -688,13 +688,13 @@ public class ComplexType
     [Fact] // issue: https://github.com/dotnet/command-line-api/issues/1365
     public void Binder_does_not_match_by_substring()
     {
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
-            new Option<string>("--bundle", "-b")
+            new CliOption<string>("--bundle", "-b")
             { 
                 Description = "the path to the app bundle to be installed"
             },
-            new Option<string>("--bundle-id", "--bundle_id", "-1")
+            new CliOption<string>("--bundle-id", "--bundle_id", "-1")
             {
                 Description = "specify bundle id for list and upload"
             }
@@ -717,8 +717,8 @@ public void Binder_does_not_match_by_substring()
     [Fact]
     public void ParseResult_GetValue_with_generic_option_returns_value()
     {
-        Option<int> option = new("--number");
-        Command command = new("the-command")
+        CliOption<int> option = new("--number");
+        CliCommand command = new("the-command")
         {
             option
         };
@@ -733,8 +733,8 @@ public void ParseResult_GetValue_with_generic_option_returns_value()
     [Fact]
     public void ParseResult_GetValue_with_generic_argument_returns_value()
     {
-        Argument<int> argument = new("arg");
-        Command command = new("the-command")
+        CliArgument<int> argument = new("arg");
+        CliCommand command = new("the-command")
         {
             argument
         };
@@ -759,10 +759,10 @@ class DeployOptions
     [InlineData("--int-value 1234")]
     public void When_only_available_constructor_is_span_then_null_is_passed(string commandLine)
     {
-        var root = new RootCommand
+        var root = new CliRootCommand
         {
-            new Option<ClassWithSpanConstructor>("--class-with-span-ctor"),
-            new Option<int>("--int-value"),
+            new CliOption<ClassWithSpanConstructor>("--class-with-span-ctor"),
+            new CliOption<int>("--int-value"),
         };
 
         var handlerWasCalled = false;
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.BindingByName.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.BindingByName.cs
index fee94ae636..5768e3b818 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.BindingByName.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.BindingByName.cs
@@ -32,7 +32,7 @@ public class BindingByName
             var handler = HandlerDescriptor.FromMethodInfo(handlerMethod)
                                            .GetCommandHandler();
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 OptionBuilder.CreateOption("--value", type)
             };
@@ -66,7 +66,7 @@ public class BindingByName
             var handler = HandlerDescriptor.FromMethodInfo(handlerMethod)
                                            .GetCommandHandler();
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 OptionBuilder.CreateOption("--value", type)
             };
@@ -100,7 +100,7 @@ public class BindingByName
             var handler = HandlerDescriptor.FromMethodInfo(handlerMethod)
                                            .GetCommandHandler();
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 OptionBuilder.CreateOption("--value", type)
             };
@@ -130,7 +130,7 @@ public class BindingByName
             var handler = HandlerDescriptor.FromMethodInfo(handlerMethod)
                                            .GetCommandHandler();
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 ArgumentBuilder.CreateArgument(type)
             };
@@ -150,9 +150,9 @@ public void When_argument_type_is_more_specific_than_parameter_type_then_paramet
         {
             FileSystemInfo received = null;
 
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
-                new Option<DirectoryInfo>("-f")
+                new CliOption<DirectoryInfo>("-f")
             };
             root.Action = CommandHandler.Create<FileSystemInfo>(f => received = f);
             var path = $"{Directory.GetCurrentDirectory()}{Path.DirectorySeparatorChar}";
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.cs
index f5f814b79a..c6c7b5ed0a 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBindingCommandHandlerTests.cs
@@ -32,7 +32,7 @@ public partial class ModelBindingCommandHandlerTests
 
         var handler = CommandHandler.Create(captureMethod);
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
             OptionBuilder.CreateOption("-x", parameterType)
         };
@@ -107,7 +107,7 @@ public partial class ModelBindingCommandHandlerTests
             handler = CommandHandler.Create((Delegate)@delegate);
         }
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
             OptionBuilder.CreateOption("--value", testCase.ParameterType)
         };
@@ -130,9 +130,9 @@ public async Task When_binding_fails_due_to_parameter_naming_mismatch_then_handl
     {
         string[] received = { "this should get overwritten" };
 
-        var o = new Option<string[]>("-i") { Description = "Path to an image or directory of supported images" };
+        var o = new CliOption<string[]>("-i") { Description = "Path to an image or directory of supported images" };
 
-        var command = new Command("command") { o };
+        var command = new CliCommand("command") { o };
         command.Action = CommandHandler.Create<string[], ParseResult>((nameDoesNotMatch, c) => received = nameDoesNotMatch);
         CommandLineConfiguration config = new(command);
         config.Error = new StringWriter();
@@ -167,7 +167,7 @@ public async Task Handler_method_receives_command_arguments_bound_to_the_specifi
 
         var handler = CommandHandler.Create(captureMethod);
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
             ArgumentBuilder.CreateArgument(type)
         };
@@ -212,7 +212,7 @@ public async Task Handler_method_receives_command_arguments_bound_to_the_specifi
 
         var argument = ArgumentBuilder.CreateArgument(testCase.ParameterType, "value");
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
             argument
         };
@@ -263,7 +263,7 @@ public async Task Handler_method_receives_command_arguments_bound_to_the_specifi
 
         var option = OptionBuilder.CreateOption("--value", testCase.ParameterType);
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
             option
         };
@@ -297,7 +297,7 @@ public async Task Unexpected_return_types_result_in_exit_code_0_if_no_exception_
             return true;
         };
 
-        var command = new Command("wat")
+        var command = new CliCommand("wat")
         {
             Action = CommandHandler.Create(@delegate)
         };
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
index 8aa283aae9..471d1efeba 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
@@ -24,9 +24,9 @@ void Execute(string name, int age)
             boundAge = age;
         }
 
-        var command = new Command("command");
-        command.Options.Add(new Option<string>("--name"));
-        command.Options.Add(new Option<int>("--age"));
+        var command = new CliCommand("command");
+        command.Options.Add(new CliOption<string>("--name"));
+        command.Options.Add(new CliOption<int>("--age"));
         command.Action = CommandHandler.Create<string, int>(Execute);
 
         await command.Parse("command --age 425 --name Gandalf").InvokeAsync();
@@ -45,9 +45,9 @@ void Execute(string firstName)
             boundFirstName = firstName;
         }
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<string>("--first-name")
+            new CliOption<string>("--first-name")
         };
         command.Action = CommandHandler.Create<string>(Execute);
 
@@ -68,9 +68,9 @@ void Execute(string name, int AGE)
             boundAge = AGE;
         }
 
-        var command = new Command("command");
-        command.Options.Add(new Option<string>("--NAME"));
-        command.Options.Add(new Option<int>("--age"));
+        var command = new CliCommand("command");
+        command.Options.Add(new CliOption<string>("--NAME"));
+        command.Options.Add(new CliOption<int>("--age"));
         command.Action = CommandHandler.Create<string, int>(Execute);
 
         await command.Parse("command --age 425 --NAME Gandalf").InvokeAsync();
@@ -91,10 +91,10 @@ void Execute(string name, int age)
             boundAge = age;
         }
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<string>("--name"),
-            new Option<int>("--age")
+            new CliOption<string>("--name"),
+            new CliOption<int>("--age")
         };
         command.Action = CommandHandler.Create<string, int>(Execute);
 
@@ -116,10 +116,10 @@ void Execute(string name, int age)
             boundAge = age;
         }
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<string>("--NAME", "-n"),
-            new Option<int>("--age", "-a")
+            new CliOption<string>("--NAME", "-n"),
+            new CliOption<int>("--age", "-a")
         };
         command.Action = CommandHandler.Create<string, int>(Execute);
 
@@ -135,10 +135,10 @@ public async Task Method_parameters_on_the_invoked_lambda_are_bound_to_matching_
         string boundName = default;
         int boundAge = default;
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<string>("--name"),
-            new Option<int>("--age")
+            new CliOption<string>("--name"),
+            new CliOption<int>("--age")
         };
         command.Action = CommandHandler.Create<string, int>((name, age) =>
         {
@@ -157,9 +157,9 @@ public async Task Nullable_parameters_are_bound_to_correct_value_when_option_is_
     {
         int? boundAge = default;
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<int?>("--age")
+            new CliOption<int?>("--age")
         };
         command.Action = CommandHandler.Create<int?>(age =>
         {
@@ -177,9 +177,9 @@ public async Task Nullable_parameters_are_bound_to_null_when_option_is_not_speci
         var wasCalled = false;
         int? boundAge = default;
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<int?>("--age")
+            new CliOption<int?>("--age")
         };
         command.Action = CommandHandler.Create<int?>(age =>
         {
@@ -199,9 +199,9 @@ public async Task Method_parameters_of_types_having_constructors_accepting_a_sin
         DirectoryInfo boundDirectoryInfo = default;
         var tempPath = Path.GetTempPath();
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<DirectoryInfo>("--dir")
+            new CliOption<DirectoryInfo>("--dir")
         };
         command.Action = CommandHandler.Create<DirectoryInfo>(dir =>
         {
@@ -218,9 +218,9 @@ public async Task Method_parameters_of_type_ParseResult_receive_the_current_Pars
     {
         ParseResult boundParseResult = default;
 
-        var option = new Option<int>("-x");
+        var option = new CliOption<int>("-x");
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
             option
         };
@@ -236,8 +236,8 @@ public async Task Method_parameters_of_type_ParseResult_receive_the_current_Bind
     {
         BindingContext boundContext = default;
 
-        var option = new Option<int>("-x");
-        var command = new Command("command")
+        var option = new CliOption<int>("-x");
+        var command = new CliCommand("command")
         {
             option
         };
@@ -267,10 +267,10 @@ public async Task Method_parameters_on_the_invoked_member_method_are_bound_to_ma
     {
         var testClass = new ExecuteTestClass();
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<string>("--name"),
-            new Option<int>("--age")
+            new CliOption<string>("--name"),
+            new CliOption<int>("--age")
         };
         command.Action = CommandHandler.Create((ExecuteTestDelegate)testClass.Execute);
 
@@ -285,10 +285,10 @@ public async Task Method_parameters_on_the_invoked_member_method_are_bound_to_ma
     {
         var testClass = new ExecuteTestClass();
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Option<string>("--name"),
-            new Option<int>("--age")
+            new CliOption<string>("--name"),
+            new CliOption<int>("--age")
         };
         command.Action = CommandHandler.Create(
             testClass.GetType().GetMethod(nameof(ExecuteTestClass.Execute)),
@@ -312,9 +312,9 @@ void Execute(string name, int age)
             boundAge = age;
         }
 
-        var command = new Command("command");
-        command.Arguments.Add(new Argument<int>("age"));
-        command.Arguments.Add(new Argument<string>("name"));
+        var command = new CliCommand("command");
+        command.Arguments.Add(new CliArgument<int>("age"));
+        command.Arguments.Add(new CliArgument<string>("name"));
         command.Action = CommandHandler.Create<string, int>(Execute);
 
         await command.Parse("command 425 Gandalf").InvokeAsync();
@@ -333,9 +333,9 @@ void Execute(string firstName)
             boundFirstName = firstName;
         }
 
-        var command = new Command("command")
+        var command = new CliCommand("command")
         {
-            new Argument<string>("first-name")
+            new CliArgument<string>("first-name")
         };
         command.Action = CommandHandler.Create<string>(Execute);
 
@@ -356,9 +356,9 @@ void Execute(string name, int AGE)
             boundAge = AGE;
         }
 
-        var command = new Command("command");
-        command.Arguments.Add(new Argument<int>("AGE"));
-        command.Arguments.Add(new Argument<string>("Name"));
+        var command = new CliCommand("command");
+        command.Arguments.Add(new CliArgument<int>("AGE"));
+        command.Arguments.Add(new CliArgument<string>("Name"));
         command.Action = CommandHandler.Create<string, int>(Execute);
 
         await command.Parse("command 425 Gandalf").InvokeAsync();
@@ -379,9 +379,9 @@ void Execute(string fullnameOrNickname, int age)
             boundAge = age;
         }
 
-        var command = new Command("command");
-        command.Arguments.Add(new Argument<int>("age"));
-        command.Arguments.Add(new Argument<string>("fullname|nickname"));
+        var command = new CliCommand("command");
+        command.Arguments.Add(new CliArgument<int>("age"));
+        command.Arguments.Add(new CliArgument<string>("fullname|nickname"));
         command.Action = CommandHandler.Create<string, int>(Execute);
 
         await command.Parse("command 425 Gandalf").InvokeAsync();
@@ -396,7 +396,7 @@ void Execute(string fullnameOrNickname, int age)
     [InlineData(typeof(OverridenVirtualTestCommandHandler), 41)]
     public async Task Method_invoked_is_matching_to_the_interface_implementation(Type type, int expectedResult)
     {
-        var command = new Command("command");
+        var command = new CliCommand("command");
         command.Action = CommandHandler.Create(type.GetMethod(nameof(CliAction.InvokeAsync)));
 
         int result = await command.Parse("command").InvokeAsync();
diff --git a/src/System.CommandLine.NamingConventionBinder/BindingContext.cs b/src/System.CommandLine.NamingConventionBinder/BindingContext.cs
index fdec69b5d7..660e6b9fec 100644
--- a/src/System.CommandLine.NamingConventionBinder/BindingContext.cs
+++ b/src/System.CommandLine.NamingConventionBinder/BindingContext.cs
@@ -88,11 +88,11 @@ public void AddService<T>(Func<IServiceProvider, T> factory)
                 }
                 else
                 {
-                    ArgumentResult argumentResult = valueDescriptor is Argument argument 
+                    ArgumentResult argumentResult = valueDescriptor is CliArgument argument 
                         ? parseResult.FindResultFor(argument) is ArgumentResult found
                             ? found
                             : new ArgumentResult(argument, parseResult.RootCommandResult.SymbolResultTree, null)
-                        : new ArgumentResult(new Argument<string>(valueDescriptor.ValueName), parseResult.RootCommandResult.SymbolResultTree, null);
+                        : new ArgumentResult(new CliArgument<string>(valueDescriptor.ValueName), parseResult.RootCommandResult.SymbolResultTree, null);
 
                     var parsed = ArgumentConverter.ConvertObject(
                         argumentResult,
diff --git a/src/System.CommandLine.NamingConventionBinder/CommandResultExtensions.cs b/src/System.CommandLine.NamingConventionBinder/CommandResultExtensions.cs
index dfc279e892..08fe59741f 100644
--- a/src/System.CommandLine.NamingConventionBinder/CommandResultExtensions.cs
+++ b/src/System.CommandLine.NamingConventionBinder/CommandResultExtensions.cs
@@ -46,7 +46,7 @@ internal static class CommandResultExtensions
 
         for (var i = 0; i < options.Count; i++)
         {
-            if (options[i] is Option option)
+            if (options[i] is CliOption option)
             {
                 var hasMatchingAlias =
                     HasMatchingAlias(valueDescriptor, option);
@@ -70,7 +70,7 @@ internal static class CommandResultExtensions
 
         static bool HasMatchingAlias(
             IValueDescriptor valueDescriptor,
-            Option option)
+            CliOption option)
         {
             string nameWithoutPrefix = RemovePrefix(option.Name);
             if (valueDescriptor.ValueName.Equals(nameWithoutPrefix, StringComparison.OrdinalIgnoreCase) || valueDescriptor.ValueName.IsMatch(nameWithoutPrefix))
diff --git a/src/System.CommandLine.NamingConventionBinder/ModelBinder.cs b/src/System.CommandLine.NamingConventionBinder/ModelBinder.cs
index d478e73053..1d49f669bb 100644
--- a/src/System.CommandLine.NamingConventionBinder/ModelBinder.cs
+++ b/src/System.CommandLine.NamingConventionBinder/ModelBinder.cs
@@ -52,7 +52,7 @@ internal ModelBinder(IValueDescriptor valueDescriptor)
     /// <param name="property">The property to bind.</param>
     /// <param name="symbol">A symbol to be used to set the property.</param>
     /// <exception cref="ArgumentException"></exception>
-    public void BindMemberFromValue(PropertyInfo property, Symbol symbol)
+    public void BindMemberFromValue(PropertyInfo property, CliSymbol symbol)
     {
         var propertyDescriptor = FindModelPropertyDescriptor(property.PropertyType, property.Name);
 
diff --git a/src/System.CommandLine.NamingConventionBinder/ModelBinder{T}.cs b/src/System.CommandLine.NamingConventionBinder/ModelBinder{T}.cs
index 56199cd316..29ed1c68fa 100644
--- a/src/System.CommandLine.NamingConventionBinder/ModelBinder{T}.cs
+++ b/src/System.CommandLine.NamingConventionBinder/ModelBinder{T}.cs
@@ -22,7 +22,7 @@ public ModelBinder() : base(typeof(TModel))
     /// <typeparam name="TValue">The type of the value to be bound.</typeparam>
     public void BindMemberFromValue<TValue>(
         Expression<Func<TModel, TValue>> property,
-        Symbol symbol)
+        CliSymbol symbol)
     {
         var (propertyType, propertyName) = property.MemberTypeAndName();
         var propertyDescriptor = FindModelPropertyDescriptor(propertyType, propertyName);
diff --git a/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs b/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs
index a643cecf19..7f7aa88180 100644
--- a/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs
+++ b/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs
@@ -92,22 +92,22 @@ public override async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
     }
 
     /// <summary>
-    /// Binds a method or constructor parameter based on the specified <see cref="Argument"/>.
+    /// Binds a method or constructor parameter based on the specified <see cref="CliArgument"/>.
     /// </summary>
     /// <param name="param">The parameter to bind.</param>
     /// <param name="argument">The argument whose parsed result will be the source of the bound value.</param>
-    public void BindParameter(ParameterInfo param, Argument argument)
+    public void BindParameter(ParameterInfo param, CliArgument argument)
     {
         var _ = argument ?? throw new InvalidOperationException("You must specify an argument to bind");
         BindValueSource(param, new SpecificSymbolValueSource(argument));
     }
 
     /// <summary>
-    /// Binds a method or constructor parameter based on the specified <see cref="Option"/>.
+    /// Binds a method or constructor parameter based on the specified <see cref="CliOption"/>.
     /// </summary>
     /// <param name="param">The parameter to bind.</param>
     /// <param name="option">The option whose parsed result will be the source of the bound value.</param>
-    public void BindParameter(ParameterInfo param, Option option)
+    public void BindParameter(ParameterInfo param, CliOption option)
     {
         var _ = option ?? throw new InvalidOperationException("You must specify an option to bind");
         BindValueSource(param, new SpecificSymbolValueSource(option));
diff --git a/src/System.CommandLine.NamingConventionBinder/SpecificSymbolValueSource.cs b/src/System.CommandLine.NamingConventionBinder/SpecificSymbolValueSource.cs
index 1f1787592d..11c12c296e 100644
--- a/src/System.CommandLine.NamingConventionBinder/SpecificSymbolValueSource.cs
+++ b/src/System.CommandLine.NamingConventionBinder/SpecificSymbolValueSource.cs
@@ -7,9 +7,9 @@ namespace System.CommandLine.NamingConventionBinder;
 
 internal class SpecificSymbolValueSource : IValueSource
 {
-    private readonly Symbol _symbol;
+    private readonly CliSymbol _symbol;
 
-    public SpecificSymbolValueSource(Symbol symbol)
+    public SpecificSymbolValueSource(CliSymbol symbol)
     {
         _symbol = symbol ?? throw new ArgumentNullException(nameof(symbol));
     }
@@ -20,7 +20,7 @@ public SpecificSymbolValueSource(Symbol symbol)
     {
         switch (_symbol)
         {
-            case Option option:
+            case CliOption option:
                 var optionResult = bindingContext?.ParseResult.FindResultFor(option);
                 if (optionResult is not null)
                 {
@@ -28,7 +28,7 @@ public SpecificSymbolValueSource(Symbol symbol)
                     return true;
                 }
                 break;
-            case Argument argument:
+            case CliArgument argument:
                 var argumentResult = bindingContext?.ParseResult.FindResultFor(argument);
                 if (argumentResult is not null)
                 {
diff --git a/src/System.CommandLine.Rendering.Tests/TableRenderingTests.cs b/src/System.CommandLine.Rendering.Tests/TableRenderingTests.cs
index a2319202bb..23a067e5df 100644
--- a/src/System.CommandLine.Rendering.Tests/TableRenderingTests.cs
+++ b/src/System.CommandLine.Rendering.Tests/TableRenderingTests.cs
@@ -34,8 +34,8 @@ public TableRenderingTests(ITestOutputHelper output)
         public void A_row_is_written_for_each_item_and_a_header_for_each_column(OutputMode outputMode)
         {
             var options = new[] {
-                new Option<string>("-s") { Description = "a short option" },
-                new Option<string>("--very-long") { Description = "a long option" }
+                new CliOption<string>("-s") { Description = "a short option" },
+                new CliOption<string>("--very-long") { Description = "a long option" }
             };
 
             var view = new OptionsHelpView(options);
@@ -57,8 +57,8 @@ public void A_row_is_written_for_each_item_and_a_header_for_each_column_in_file_
         {
             var options = new[]
             {
-                new Option<string>("-s") { Description = "a short option" },
-                new Option<string>("--very-long") { Description = "a long option" }
+                new CliOption<string>("-s") { Description = "a short option" },
+                new CliOption<string>("--very-long") { Description = "a long option" }
             };
 
             var view = new OptionsHelpView(options);
@@ -80,8 +80,8 @@ public void A_row_is_written_for_each_item_and_a_header_for_each_column_in_file_
         public void Column_widths_are_aligned_to_the_longest_cell(OutputMode outputMode)
         {
             var options = new[] {
-                new Option<string>("-s") { Description = "an option" },
-                new Option<string>("--very-long") { Description = "an option" },
+                new CliOption<string>("-s") { Description = "an option" },
+                new CliOption<string>("--very-long") { Description = "an option" },
             };
 
             var view = new OptionsHelpView(options);
@@ -101,8 +101,8 @@ public void Column_widths_are_aligned_to_the_longest_cell(OutputMode outputMode)
         public void Column_widths_are_aligned_to_the_longest_cell_in_file_mode()
         {
             var options = new[] {
-                new Option<string>("-s") { Description = "an option" },
-                new Option<string>("--very-long") { Description = "an option" },
+                new CliOption<string>("-s") { Description = "an option" },
+                new CliOption<string>("--very-long") { Description = "an option" },
             };
 
             var view = new OptionsHelpView(options);
@@ -121,9 +121,9 @@ public void Column_widths_are_aligned_to_the_longest_cell_in_file_mode()
         private TextRendered Cell(string text, int left, int top) => new(text, new Point(left, top));
     }
 
-    public class OptionsHelpView : TableView<Option>
+    public class OptionsHelpView : TableView<CliOption>
     {
-        public OptionsHelpView(IEnumerable<Option> options)
+        public OptionsHelpView(IEnumerable<CliOption> options)
         {
             Items = options.ToList();
 
diff --git a/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs b/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs
index 8b97b35c77..0156c8eb13 100644
--- a/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs
+++ b/src/System.CommandLine.Rendering.Tests/ViewRenderingTests.cs
@@ -22,7 +22,7 @@ public void Views_can_be_used_for_specific_types()
                 IsAnsiTerminal = false
             };
 
-            var command = new RootCommand();
+            var command = new CliRootCommand();
             command.SetAction(ctx =>
             {
                 parseResult = ctx;
diff --git a/src/System.CommandLine.Suggest.Tests/EndToEndTestApp/Program.cs b/src/System.CommandLine.Suggest.Tests/EndToEndTestApp/Program.cs
index 23f203a01b..baad863401 100644
--- a/src/System.CommandLine.Suggest.Tests/EndToEndTestApp/Program.cs
+++ b/src/System.CommandLine.Suggest.Tests/EndToEndTestApp/Program.cs
@@ -10,12 +10,12 @@ public class Program
     {
         static async Task Main(string[] args)
         {
-            var appleOption = new Option<string>("--apple" );
-            var bananaOption = new Option<string>("--banana");
-            var cherryOption = new Option<string>("--cherry");
-            var durianOption = new Option<string>("--durian");
+            CliOption<string> appleOption = new ("--apple" );
+            CliOption<string> bananaOption = new ("--banana");
+            CliOption<string> cherryOption = new ("--cherry");
+            CliOption<string> durianOption = new ("--durian");
 
-            var rootCommand = new RootCommand
+            CliRootCommand rootCommand = new ()
             {
                 appleOption,          
                 bananaOption,          
diff --git a/src/System.CommandLine.Suggest.Tests/SuggestionDispatcherTests.cs b/src/System.CommandLine.Suggest.Tests/SuggestionDispatcherTests.cs
index ca8e8a5757..b25d0adff3 100644
--- a/src/System.CommandLine.Suggest.Tests/SuggestionDispatcherTests.cs
+++ b/src/System.CommandLine.Suggest.Tests/SuggestionDispatcherTests.cs
@@ -14,7 +14,7 @@ namespace System.CommandLine.Suggest.Tests
 {
     public class SuggestionDispatcherTests
     {
-        private static readonly string _currentExeName = RootCommand.ExecutableName;
+        private static readonly string _currentExeName = CliRootCommand.ExecutableName;
         
         private static readonly string _dotnetExeFullPath = 
             DotnetMuxer.Path.FullName;
diff --git a/src/System.CommandLine.Suggest/SuggestionDispatcher.cs b/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
index dbf23a6def..c3a543f097 100644
--- a/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
+++ b/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System.CommandLine.Completions;
 
 namespace System.CommandLine.Suggest
 {
@@ -20,9 +21,9 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
 
             _suggestionStore = suggestionStore ?? new SuggestionStore();
 
-            var shellTypeArgument = new Argument<ShellType>(nameof(ShellType));
+            var shellTypeArgument = new CliArgument<ShellType>(nameof(ShellType));
 
-            CompleteScriptCommand = new Command("script", "Print complete script for specific shell")
+            CompleteScriptCommand = new CliCommand("script", "Print complete script for specific shell")
             {
                 shellTypeArgument
             };
@@ -31,7 +32,7 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
                 SuggestionShellScriptHandler.Handle(context.Configuration.Output, context.GetValue(shellTypeArgument));
             });
 
-            ListCommand = new Command("list")
+            ListCommand = new CliCommand("list")
             {
                 Description = "Lists apps registered for suggestions",
             };
@@ -41,19 +42,19 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
                 return Task.CompletedTask;
             });
 
-            GetCommand = new Command("get", "Gets suggestions from the specified executable")
+            GetCommand = new CliCommand("get", "Gets suggestions from the specified executable")
             {
                 ExecutableOption,
                 PositionOption
             };
             GetCommand.SetAction(Get);
 
-            var commandPathOption = new Option<string>("--command-path") { Description = "The path to the command for which to register suggestions" };
+            var commandPathOption = new CliOption<string>("--command-path") { Description = "The path to the command for which to register suggestions" };
 
-            RegisterCommand = new Command("register", "Registers an app for suggestions")
+            RegisterCommand = new CliCommand("register", "Registers an app for suggestions")
             {
                 commandPathOption,
-                new Option<string>("--suggestion-command") { Description = "The command to invoke to retrieve suggestions" }
+                new CliOption<string>("--suggestion-command") { Description = "The command to invoke to retrieve suggestions" }
             };
 
             RegisterCommand.SetAction((context, cancellationToken) =>
@@ -62,7 +63,7 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
                 return Task.CompletedTask;
             });
 
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
                 ListCommand,
                 GetCommand,
@@ -74,35 +75,35 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
             {
                 Directives =
                 {
-                    new ParseDirective(),
+                    new ParseDiagramDirective(),
                     new SuggestDirective(),
                 }
             };
         }
 
-        private Command CompleteScriptCommand { get; }
+        private CliCommand CompleteScriptCommand { get; }
 
-        private Command GetCommand { get; }
+        private CliCommand GetCommand { get; }
 
-        private Option<FileInfo> ExecutableOption { get; } = GetExecutableOption();
+        private CliOption<FileInfo> ExecutableOption { get; } = GetExecutableOption();
 
-        private static Option<FileInfo> GetExecutableOption()
+        private static CliOption<FileInfo> GetExecutableOption()
         {
-            var option = new Option<FileInfo>("--executable", "-e") { Description = "The executable to call for suggestions" };
+            var option = new CliOption<FileInfo>("--executable", "-e") { Description = "The executable to call for suggestions" };
             option.AcceptLegalFilePathsOnly();
 
             return option;
         }
 
-        private Command ListCommand { get; }
+        private CliCommand ListCommand { get; }
 
-        private Option<int> PositionOption { get; } = new("--position", "-p")
+        private CliOption<int> PositionOption { get; } = new("--position", "-p")
         {
             Description = "The current character position on the command line",
             DefaultValueFactory = (_) => short.MaxValue
         };
 
-        private Command RegisterCommand { get; }
+        private CliCommand RegisterCommand { get; }
 
         public CommandLineConfiguration Configuration { get; }
 
diff --git a/src/System.CommandLine.Tests/ArgumentTests.cs b/src/System.CommandLine.Tests/ArgumentTests.cs
index c688ffdee6..f244d2fe61 100644
--- a/src/System.CommandLine.Tests/ArgumentTests.cs
+++ b/src/System.CommandLine.Tests/ArgumentTests.cs
@@ -17,7 +17,7 @@ public class ArgumentTests
         [Fact]
         public void By_default_there_is_no_default_value()
         {
-            var argument = new Argument<string>("arg");
+            var argument = new CliArgument<string>("arg");
 
             argument.HasDefaultValue.Should().BeFalse();
         }
@@ -25,7 +25,7 @@ public void By_default_there_is_no_default_value()
         [Fact]
         public void When_default_value_factory_is_set_then_HasDefaultValue_is_true()
         {
-            var argument = new Argument<string[]>("arg");
+            var argument = new CliArgument<string[]>("arg");
 
             argument.DefaultValueFactory = (_) => null;
 
@@ -35,7 +35,7 @@ public void When_default_value_factory_is_set_then_HasDefaultValue_is_true()
         [Fact]
         public void When_there_is_no_default_value_then_GetDefaultValue_throws()
         {
-            var argument = new Argument<string>("the-arg");
+            var argument = new CliArgument<string>("the-arg");
 
             argument.Invoking(a => a.GetDefaultValue())
                     .Should()
@@ -51,7 +51,7 @@ public class CustomParsing
             [Fact]
             public void HasDefaultValue_can_be_set_to_true()
             {
-                var argument = new Argument<FileSystemInfo>("arg")
+                var argument = new CliArgument<FileSystemInfo>("arg")
                 {
                     DefaultValueFactory = result => null
                 };
@@ -64,7 +64,7 @@ public void HasDefaultValue_can_be_set_to_true()
             [Fact]
             public void HasDefaultValue_can_be_set_to_false()
             {
-                var argument = new Argument<FileSystemInfo>("arg")
+                var argument = new CliArgument<FileSystemInfo>("arg")
                 {
                     DefaultValueFactory = null
                 };
@@ -77,7 +77,7 @@ public void HasDefaultValue_can_be_set_to_false()
             [Fact]
             public void GetDefaultValue_returns_specified_value()
             {
-                var argument = new Argument<string>("arg")
+                var argument = new CliArgument<string>("arg")
                 {
                     DefaultValueFactory = result => "the-default"
                 };
@@ -90,7 +90,7 @@ public void GetDefaultValue_returns_specified_value()
             [Fact]
             public void GetDefaultValue_returns_null_when_parse_delegate_returns_true_without_setting_a_value()
             {
-                var argument = new Argument<string>("arg")
+                var argument = new CliArgument<string>("arg")
                 {
                     DefaultValueFactory = result => null
                 };
@@ -103,7 +103,7 @@ public void GetDefaultValue_returns_null_when_parse_delegate_returns_true_withou
             [Fact]
             public void GetDefaultValue_can_return_null()
             {
-                var argument = new Argument<string>("arg")
+                var argument = new CliArgument<string>("arg")
                 {
                     DefaultValueFactory = result => null
                 };
@@ -116,7 +116,7 @@ public void GetDefaultValue_can_return_null()
             [Fact]
             public void Validation_failure_message_can_be_specified_when_parsing_tokens()
             {
-                var argument = new Argument<FileSystemInfo>("arg")
+                var argument = new CliArgument<FileSystemInfo>("arg")
                 {
                     CustomParser = result =>
                     {
@@ -125,7 +125,7 @@ public void Validation_failure_message_can_be_specified_when_parsing_tokens()
                     }
                 };
 
-                new RootCommand { argument }.Parse("x")
+                new CliRootCommand { argument }.Parse("x")
                         .Errors
                         .Should()
                         .ContainSingle(e => ((ArgumentResult)e.SymbolResult).Argument == argument)
@@ -138,7 +138,7 @@ public void Validation_failure_message_can_be_specified_when_parsing_tokens()
             [Fact]
             public void Validation_failure_message_can_be_specified_when_evaluating_default_argument_value()
             {
-                var argument = new Argument<FileSystemInfo>("arg")
+                var argument = new CliArgument<FileSystemInfo>("arg")
                 {
                     DefaultValueFactory = result =>
                     {
@@ -147,7 +147,7 @@ public void Validation_failure_message_can_be_specified_when_evaluating_default_
                     }
                 };
 
-                new RootCommand { argument }.Parse("")
+                new CliRootCommand { argument }.Parse("")
                         .Errors
                         .Should()
                         .ContainSingle(e => ((ArgumentResult)e.SymbolResult).Argument == argument)
@@ -160,7 +160,7 @@ public void Validation_failure_message_can_be_specified_when_evaluating_default_
             [Fact]
             public void Validation_failure_message_can_be_specified_when_evaluating_default_option_value()
             {
-                var option = new Option<FileSystemInfo>("-x")
+                var option = new CliOption<FileSystemInfo>("-x")
                 {
                     DefaultValueFactory = result =>
                     {
@@ -169,7 +169,7 @@ public void Validation_failure_message_can_be_specified_when_evaluating_default_
                     }
                 };
 
-                new RootCommand { option }.Parse("")
+                new CliRootCommand { option }.Parse("")
                       .Errors
                       .Should()
                       .ContainSingle()
@@ -182,12 +182,12 @@ public void Validation_failure_message_can_be_specified_when_evaluating_default_
             [Fact]
             public void custom_parsing_of_scalar_value_from_an_argument_with_one_token()
             {
-                var argument = new Argument<int>("arg")
+                var argument = new CliArgument<int>("arg")
                 {
                     CustomParser = result => int.Parse(result.Tokens.Single().Value)
                 };
 
-                new RootCommand { argument }.Parse("123")
+                new CliRootCommand { argument }.Parse("123")
                         .GetValue(argument)
                         .Should()
                         .Be(123);
@@ -196,12 +196,12 @@ public void custom_parsing_of_scalar_value_from_an_argument_with_one_token()
             [Fact]
             public void custom_parsing_of_sequence_value_from_an_argument_with_one_token()
             {
-                var argument = new Argument<IEnumerable<int>>("arg")
+                var argument = new CliArgument<IEnumerable<int>>("arg")
                 {
                     CustomParser = result => result.Tokens.Single().Value.Split(',').Select(int.Parse)
                 };
 
-                new RootCommand { argument }.Parse("1,2,3")
+                new CliRootCommand { argument }.Parse("1,2,3")
                         .GetValue(argument)
                         .Should()
                         .BeEquivalentTo(new[] { 1, 2, 3 });
@@ -210,12 +210,12 @@ public void custom_parsing_of_sequence_value_from_an_argument_with_one_token()
             [Fact]
             public void custom_parsing_of_sequence_value_from_an_argument_with_multiple_tokens()
             {
-                var argument = new Argument<IEnumerable<int>>("arg")
+                var argument = new CliArgument<IEnumerable<int>>("arg")
                 {
                     CustomParser = result => result.Tokens.Select(t => int.Parse(t.Value)).ToArray()
                 };
 
-                new RootCommand { argument }.Parse("1 2 3")
+                new CliRootCommand { argument }.Parse("1 2 3")
                         .GetValue(argument)
                         .Should()
                         .BeEquivalentTo(new[] { 1, 2, 3 });
@@ -224,13 +224,13 @@ public void custom_parsing_of_sequence_value_from_an_argument_with_multiple_toke
             [Fact]
             public void custom_parsing_of_scalar_value_from_an_argument_with_multiple_tokens()
             {
-                var argument = new Argument<int>("arg")
+                var argument = new CliArgument<int>("arg")
                 {
                     CustomParser = result => result.Tokens.Select(t => int.Parse(t.Value)).Sum(),
                     Arity = ArgumentArity.ZeroOrMore
                 };
 
-                new RootCommand { argument }.Parse("1 2 3")
+                new CliRootCommand { argument }.Parse("1 2 3")
                         .GetValue(argument)
                         .Should()
                         .Be(6);
@@ -241,9 +241,9 @@ public void Option_ArgumentResult_Parent_is_set_correctly_when_token_is_implicit
             {
                 ArgumentResult argumentResult = null;
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                     {
                         DefaultValueFactory = argResult =>
                         {
@@ -271,9 +271,9 @@ public void Option_ArgumentResult_parentage_to_root_symbol_is_set_correctly_when
             {
                 ArgumentResult argumentResult = null;
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                     {
                         DefaultValueFactory = argResult =>
                         {
@@ -302,12 +302,12 @@ public void Option_ArgumentResult_parentage_to_root_symbol_is_set_correctly_when
             public void Symbol_can_be_found_without_explicitly_traversing_result_tree(string commandLine)
             {
                 SymbolResult resultForOptionX = null;
-                var optionX = new Option<string>("-x")
+                var optionX = new CliOption<string>("-x")
                 {
                     CustomParser = _ => string.Empty
                 };
                 
-                var optionY = new Option<string>("-y")
+                var optionY = new CliOption<string>("-y")
                 {
                     CustomParser = argResult =>
                     {
@@ -316,7 +316,7 @@ public void Symbol_can_be_found_without_explicitly_traversing_result_tree(string
                     }
                 };
             
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     optionX,
                     optionY,
@@ -338,9 +338,9 @@ public void Command_ArgumentResult_Parent_is_set_correctly_when_token_is_implici
             {
                 ArgumentResult argumentResult = null;
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
-                    new Argument<string>("arg")
+                    new CliArgument<string>("arg")
                     {
                         DefaultValueFactory = argResult =>
                         {
@@ -368,7 +368,7 @@ public async Task Custom_argument_parser_is_only_called_once()
                 var callCount = 0;
                 var handlerWasCalled = false;
 
-                var option = new Option<int>("--value")
+                var option = new CliOption<int>("--value")
                 {
                     CustomParser = result =>
                     {
@@ -377,7 +377,7 @@ public async Task Custom_argument_parser_is_only_called_once()
                     }
                 };
 
-                var command = new RootCommand();
+                var command = new CliRootCommand();
                 command.SetAction((ctx) => handlerWasCalled = true);
                 command.Options.Add(option);
 
@@ -390,13 +390,13 @@ public async Task Custom_argument_parser_is_only_called_once()
             [Fact]
             public void Default_value_and_custom_argument_parser_can_be_used_together()
             {
-                var argument = new Argument<int>("arg")
+                var argument = new CliArgument<int>("arg")
                 {
                     CustomParser = _ => 789,
                     DefaultValueFactory = _ => 123
                 };
 
-                var result = new RootCommand { argument }.Parse("");
+                var result = new CliRootCommand { argument }.Parse("");
 
                 result.GetValue(argument)
                       .Should()
@@ -406,9 +406,9 @@ public void Default_value_and_custom_argument_parser_can_be_used_together()
             [Fact]
             public void Multiple_command_arguments_can_have_custom_parse_delegates()
             {
-                var root = new RootCommand
+                var root = new CliRootCommand
                 {
-                    new Argument<FileInfo[]>("from")
+                    new CliArgument<FileInfo[]>("from")
                     {
                         CustomParser = argumentResult =>
                         {
@@ -417,7 +417,7 @@ public void Multiple_command_arguments_can_have_custom_parse_delegates()
                         },
                         Arity = new ArgumentArity(0, 2)
                     },
-                    new Argument<DirectoryInfo>("to")
+                    new CliArgument<DirectoryInfo>("to")
                     {
                         CustomParser = argumentResult =>
                         {
@@ -444,10 +444,10 @@ public void Multiple_command_arguments_can_have_custom_parse_delegates()
             [Fact]
             public void When_custom_conversion_fails_then_an_option_does_not_accept_further_arguments()
             {
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
-                    new Argument<string>("arg"),
-                    new Option<string>("-x")
+                    new CliArgument<string>("arg"),
+                    new CliOption<string>("-x")
                     {
                         CustomParser = argResult =>
                         {
@@ -465,7 +465,7 @@ public void When_custom_conversion_fails_then_an_option_does_not_accept_further_
             [Fact]
             public void When_argument_cannot_be_parsed_as_the_specified_type_then_getting_value_throws()
             {
-                var option = new Option<int>("--one", "-o")
+                var option = new CliOption<int>("--one", "-o")
                 {
                     CustomParser = argumentResult =>
                     {
@@ -480,7 +480,7 @@ public void When_argument_cannot_be_parsed_as_the_specified_type_then_getting_va
                     }
                 };
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     option
                 };
@@ -503,9 +503,9 @@ public void Parse_delegate_is_called_once_per_parse_operation_when_input_is_prov
             {
                 var i = 0;
 
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
-                    new Option<int>("-x")
+                    new CliOption<int>("-x")
                     {
                         CustomParser = result => ++i,
                     }
@@ -522,9 +522,9 @@ public void Default_value_factory_is_called_once_per_parse_operation_when_no_inp
             {
                 var i = 0;
 
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
-                    new Option<int>("-x")
+                    new CliOption<int>("-x")
                     {
                         DefaultValueFactory = result => ++i,
                     }
@@ -546,7 +546,7 @@ public void Custom_parser_when_configured_as_default_value_factory_is_called_whe
                 {
                     if (result.Tokens.Count == 0)
                     {
-                        if (result.Parent is OptionResult { IsImplicit: true })
+                        if (result.Parent is OptionResult { Implicit: true })
                         {
                             return "option-is-implicit";
                         }
@@ -559,14 +559,14 @@ public void Custom_parser_when_configured_as_default_value_factory_is_called_whe
                     }
                 };
 
-                var opt = new Option<string>("--bananas")
+                var opt = new CliOption<string>("--bananas")
                 {
                     DefaultValueFactory = both,
                     CustomParser = both,
                     Arity = ArgumentArity.ZeroOrOne
                 };
 
-                var rootCommand = new RootCommand
+                var rootCommand = new CliRootCommand
                 {
                     opt
                 };
@@ -580,7 +580,7 @@ public void Custom_parser_when_configured_as_default_value_factory_is_called_whe
             [InlineData("1 2 3 -o 999 4 5 6 7 8")]
             public void Custom_parser_can_pass_on_remaining_tokens(string commandLine)
             {
-                var argument1 = new Argument<int[]>("one")
+                var argument1 = new CliArgument<int[]>("one")
                 {
                     CustomParser = result =>
                     {
@@ -594,15 +594,15 @@ public void Custom_parser_can_pass_on_remaining_tokens(string commandLine)
                         };
                     }
                 };
-                var argument2 = new Argument<int[]>("two")
+                var argument2 = new CliArgument<int[]>("two")
                 {
                     CustomParser = result => result.Tokens.Select(t => t.Value).Select(int.Parse).ToArray()
                 };
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
                     argument1,
                     argument2,
-                    new Option<int>("-o")
+                    new CliOption<int>("-o")
                 };
 
                 var parseResult = command.Parse(commandLine);
@@ -624,7 +624,7 @@ public void Custom_parser_can_pass_on_remaining_tokens(string commandLine)
             public void When_tokens_are_passed_on_by_custom_parser_on_last_argument_then_they_become_unmatched_tokens()
             {
 
-                var argument1 = new Argument<int[]>("one")
+                var argument1 = new CliArgument<int[]>("one")
                 {
                     CustomParser = result =>
                     {
@@ -639,7 +639,7 @@ public void When_tokens_are_passed_on_by_custom_parser_on_last_argument_then_the
                     }
                 };
              
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
                     argument1
                 };
@@ -655,7 +655,7 @@ public void When_tokens_are_passed_on_by_custom_parser_on_last_argument_then_the
             [Fact]
             public void When_custom_parser_passes_on_tokens_the_argument_result_tokens_reflect_the_change()
             {
-                var argument1 = new Argument<int[]>("one")
+                var argument1 = new CliArgument<int[]>("one")
                 {
                     CustomParser = result =>
                     {
@@ -669,11 +669,11 @@ public void When_custom_parser_passes_on_tokens_the_argument_result_tokens_refle
                         };
                     }
                 };
-                var argument2 = new Argument<int[]>("two")
+                var argument2 = new CliArgument<int[]>("two")
                 {
                     CustomParser = result => result.Tokens.Select(t => t.Value).Select(int.Parse).ToArray()
                 };
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
                     argument1,
                     argument2
@@ -699,7 +699,7 @@ public void When_custom_parser_passes_on_tokens_the_argument_result_tokens_refle
             [Fact]
             public void OnlyTake_throws_when_called_with_a_negative_value()
             {
-                 var argument = new Argument<int[]>("one")
+                 var argument = new CliArgument<int[]>("one")
                  {
                      CustomParser = result =>
                      {
@@ -709,7 +709,7 @@ public void OnlyTake_throws_when_called_with_a_negative_value()
                      }
                  };
 
-                 argument.Invoking(a => new RootCommand { a }.Parse("1 2 3"))
+                 argument.Invoking(a => new CliRootCommand { a }.Parse("1 2 3"))
                          .Should()
                          .Throw<ArgumentOutOfRangeException>()
                          .Which
@@ -721,7 +721,7 @@ public void OnlyTake_throws_when_called_with_a_negative_value()
             [Fact]
             public void OnlyTake_throws_when_called_twice()
             {
-                 var argument = new Argument<int[]>("one")
+                 var argument = new CliArgument<int[]>("one")
                  {
                      CustomParser = result =>
                     {
@@ -732,7 +732,7 @@ public void OnlyTake_throws_when_called_twice()
                     }
                  };
 
-                 argument.Invoking(a => new RootCommand { a }.Parse("1 2 3"))
+                 argument.Invoking(a => new CliRootCommand { a }.Parse("1 2 3"))
                          .Should()
                          .Throw<InvalidOperationException>()
                          .Which
@@ -744,7 +744,7 @@ public void OnlyTake_throws_when_called_twice()
             [Fact]
             public void OnlyTake_can_pass_on_all_tokens_from_one_multiple_arity_argument_to_another()
             {
-                var argument1 = new Argument<int[]>("arg1")
+                var argument1 = new CliArgument<int[]>("arg1")
                 {
                     CustomParser = result =>
                     {
@@ -752,8 +752,8 @@ public void OnlyTake_can_pass_on_all_tokens_from_one_multiple_arity_argument_to_
                         return null;
                     }
                 };
-                var argument2 = new Argument<int[]>("arg2");
-                var command = new RootCommand
+                var argument2 = new CliArgument<int[]>("arg2");
+                var command = new CliRootCommand
                 {
                     argument1,
                     argument2
@@ -769,7 +769,7 @@ public void OnlyTake_can_pass_on_all_tokens_from_one_multiple_arity_argument_to_
             [Fact] // https://github.com/dotnet/command-line-api/issues/1759 
             public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_another()
             {
-                var scalar = new Argument<int?>("arg")
+                var scalar = new CliArgument<int?>("arg")
                 {
                     CustomParser = ctx =>
                     {
@@ -777,9 +777,9 @@ public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_anot
                         return null;
                     }
                 };
-                Argument<int[]> multiple = new("args");
+                CliArgument<int[]> multiple = new("args");
 
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
                     scalar,
                     multiple
@@ -796,7 +796,7 @@ public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_anot
             [Fact] //https://github.com/dotnet/command-line-api/issues/1779
             public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_another_that_also_passes_them_all_on()
             {
-                var first = new Argument<string>("first")
+                var first = new CliArgument<string>("first")
                 {
                     CustomParser = ctx =>
                     {
@@ -806,7 +806,7 @@ public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_anot
                     Arity = ArgumentArity.ZeroOrOne
                 };
 
-                var second = new Argument<string[]>(name: "second")
+                var second = new CliArgument<string[]>(name: "second")
                 {
                     CustomParser = ctx =>
                     {
@@ -816,7 +816,7 @@ public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_anot
                     Arity = ArgumentArity.ZeroOrMore
                 };
 
-                var third = new Argument<string[]>(name: "third")
+                var third = new CliArgument<string[]>(name: "third")
                 {
                     CustomParser = ctx =>
                     {
@@ -826,7 +826,7 @@ public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_anot
                     Arity = ArgumentArity.ZeroOrMore
                 };
 
-                var command = new RootCommand
+                var command = new CliRootCommand
                 {
                     first,
                     second,
@@ -844,10 +844,10 @@ public void OnlyTake_can_pass_on_all_tokens_from_a_single_arity_argument_to_anot
         [Fact]
         public void Argument_of_enum_can_limit_enum_members_as_valid_values()
         {
-            var argument = new Argument<ConsoleColor>("color");
+            var argument = new CliArgument<ConsoleColor>("color");
             argument.AcceptOnlyFromAmong(ConsoleColor.Red.ToString(), ConsoleColor.Green.ToString());
 
-            Command command = new("set-color")
+            CliCommand command = new("set-color")
             {
                 argument
             };
diff --git a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
index bbb0337dba..e606dcfc71 100644
--- a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
+++ b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
@@ -14,22 +14,22 @@ namespace System.CommandLine.Tests.Binding
 {
     public class TypeConversionTests
     {
-        protected virtual T GetValue<T>(Option<T> option, string commandLine)
+        protected virtual T GetValue<T>(CliOption<T> option, string commandLine)
         {
-            var result = new RootCommand { option }.Parse(commandLine);
+            var result = new CliRootCommand { option }.Parse(commandLine);
             return result.GetValue(option);
         }
 
-        protected virtual T GetValue<T>(Argument<T> argument, string commandLine)
+        protected virtual T GetValue<T>(CliArgument<T> argument, string commandLine)
         {
-            var result = new RootCommand { argument }.Parse(commandLine);
+            var result = new CliRootCommand { argument }.Parse(commandLine);
             return result.GetValue(argument);
         }
 
         [Fact]
         public void Option_argument_of_FileInfo_can_be_bound_without_custom_conversion_logic()
         {
-            var option = new Option<FileInfo>("--file");
+            var option = new CliOption<FileInfo>("--file");
 
             var file = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "the-file.txt"));
 
@@ -42,9 +42,9 @@ public void Option_argument_of_FileInfo_can_be_bound_without_custom_conversion_l
         [Fact]
         public void Command_argument_of_FileInfo_can_be_bound_without_custom_conversion_logic()
         {
-            var argument = new Argument<FileInfo>("the-arg");
+            var argument = new CliArgument<FileInfo>("the-arg");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 argument
             };
@@ -61,11 +61,11 @@ public void Command_argument_of_FileInfo_can_be_bound_without_custom_conversion_
         [Fact]
         public void Command_argument_of_FileInfo_returns_null_when_argument_is_not_provided()
         {
-            var argument = new Argument<FileInfo>("the-arg")
+            var argument = new CliArgument<FileInfo>("the-arg")
             {
                 Arity = ArgumentArity.ZeroOrOne
             };
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 argument
             };
@@ -80,8 +80,8 @@ public void Command_argument_of_FileInfo_returns_null_when_argument_is_not_provi
         [Fact]
         public void Argument_of_FileInfo_that_is_empty_results_in_an_informative_error()
         {
-            var option = new Option<FileInfo>("--file");
-            var result = new RootCommand { option }.Parse(new string[] { "--file", "" });
+            var option = new CliOption<FileInfo>("--file");
+            var result = new CliRootCommand { option }.Parse(new string[] { "--file", "" });
 
             result.Errors
                   .Should()
@@ -95,7 +95,7 @@ public void Argument_of_FileInfo_that_is_empty_results_in_an_informative_error()
         [Fact]
         public void Argument_of_array_of_FileInfo_can_be_called_without_custom_conversion_logic()
         {
-            var option = new Option<FileInfo[]>("--file");
+            var option = new CliOption<FileInfo[]>("--file");
 
             var file1 = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "file1.txt"));
             var file2 = new FileInfo(Path.Combine(new DirectoryInfo("temp").FullName, "file2.txt"));
@@ -109,7 +109,7 @@ public void Argument_of_array_of_FileInfo_can_be_called_without_custom_conversio
         [Fact]
         public void Argument_defaults_arity_to_One_for_non_IEnumerable_types()
         {
-            var argument = new Argument<int>("arg");
+            var argument = new CliArgument<int>("arg");
 
             argument.Arity.Should().BeEquivalentTo(ArgumentArity.ExactlyOne);
         }
@@ -117,7 +117,7 @@ public void Argument_defaults_arity_to_One_for_non_IEnumerable_types()
         [Fact]
         public void Argument_defaults_arity_to_ExactlyOne_for_string()
         {
-            var argument = new Argument<string>("arg");
+            var argument = new CliArgument<string>("arg");
 
             argument.Arity.Should().BeEquivalentTo(ArgumentArity.ExactlyOne);
         }
@@ -125,9 +125,9 @@ public void Argument_defaults_arity_to_ExactlyOne_for_string()
         [Fact]
         public void Command_Argument_defaults_arity_to_ZeroOrOne_for_nullable_types()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<int?>("arg")
+                new CliArgument<int?>("arg")
             };
 
             command.Arguments.Single().Arity.Should().BeEquivalentTo(ArgumentArity.ZeroOrOne);
@@ -147,9 +147,9 @@ public void Argument_infers_arity_of_IEnumerable_types_as_OneOrMore(Type type)
         [Fact]
         public void Argument_parses_as_the_default_value_when_the_option_has_not_been_applied()
         {
-            var option = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var option = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -162,9 +162,9 @@ public void Argument_parses_as_the_default_value_when_the_option_has_not_been_ap
         [Fact]
         public void Option_does_not_parse_as_the_default_value_when_the_option_has_been_applied()
         {
-            var option = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var option = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -181,9 +181,9 @@ public void Option_does_not_parse_as_the_default_value_when_the_option_has_been_
         [InlineData("the-command -x=true")]
         public void Bool_parses_as_true_when_the_option_has_been_applied(string commandLine)
         {
-            var option = new Option<bool>("-x");
+            var option = new CliOption<bool>("-x");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -202,9 +202,9 @@ public void Bool_parses_as_true_when_the_option_has_been_applied(string commandL
         [InlineData("the-command -x=true")]
         public void Nullable_bool_parses_as_true_when_the_option_has_been_applied(string commandLine)
         {
-            var option = new Option<bool?>("-x");
+            var option = new CliOption<bool?>("-x");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -222,9 +222,9 @@ public void Nullable_bool_parses_as_true_when_the_option_has_been_applied(string
         [InlineData("the-command -x=false")]
         public void Nullable_bool_parses_as_false_when_the_option_has_been_applied(string commandLine)
         {
-            var option = new Option<bool?>("-x");
+            var option = new CliOption<bool?>("-x");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -239,7 +239,7 @@ public void Nullable_bool_parses_as_false_when_the_option_has_been_applied(strin
         [Fact]
         public void Nullable_bool_parses_as_null_when_the_option_has_not_been_applied()
         {
-            var option = new Option<bool?>("-x");
+            var option = new CliOption<bool?>("-x");
 
             GetValue(option, "")
                 .Should()
@@ -249,9 +249,9 @@ public void Nullable_bool_parses_as_null_when_the_option_has_not_been_applied()
         [Fact]
         public void When_exactly_one_argument_is_expected_and_none_are_provided_then_getting_value_throws()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -274,14 +274,14 @@ public void When_exactly_one_argument_is_expected_and_none_are_provided_then_get
         [InlineData("c c c")]
         public void When_command_argument_has_arity_greater_than_one_it_captures_arguments_before_and_after_option(string commandLine)
         {
-            var argument = new Argument<string[]>("the-arg")
+            var argument = new CliArgument<string[]>("the-arg")
             {
                 Arity = ArgumentArity.ZeroOrMore
             };
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("-a"),
+                new CliOption<string>("-a"),
                 argument
             };
 
@@ -295,10 +295,10 @@ public void When_command_argument_has_arity_greater_than_one_it_captures_argumen
         [Fact]
         public void The_default_value_of_a_bool_option_with_no_arguments_is_true()
         {
-            var option = new Option<bool>("-x");
+            var option = new CliOption<bool>("-x");
 
             var command =
-                new Command("the-command")
+                new CliCommand("the-command")
                 {
                     option
                 };
@@ -313,9 +313,9 @@ public void The_default_value_of_a_bool_option_with_no_arguments_is_true()
         [Fact]
         public void By_default_a_bool_option_without_arguments_parses_as_false_when_it_is_not_applied()
         {
-            var option = new Option<bool>("-x");
+            var option = new CliOption<bool>("-x");
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -330,9 +330,9 @@ public void By_default_a_bool_option_without_arguments_parses_as_false_when_it_i
         [Fact]
         public void An_option_with_a_default_value_parses_as_the_default_value_when_the_option_has_not_been_applied()
         {
-            var option = new Option<string>("-x") { DefaultValueFactory = (_) => "123" };
+            var option = new CliOption<string>("-x") { DefaultValueFactory = (_) => "123" };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -347,9 +347,9 @@ public void An_option_with_a_default_value_parses_as_the_default_value_when_the_
         [Fact]
         public void An_option_with_a_default_value_of_null_parses_as_null_when_the_option_has_not_been_applied()
         {
-            var option = new Option<string>("-x") { DefaultValueFactory = (_) => null };
+            var option = new CliOption<string>("-x") { DefaultValueFactory = (_) => null };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -364,9 +364,9 @@ public void An_option_with_a_default_value_of_null_parses_as_null_when_the_optio
         [Fact]
         public void A_default_value_of_a_non_string_type_can_be_specified()
         {
-            var option = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var option = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -382,9 +382,9 @@ public void A_default_value_with_a_custom_constructor_can_be_specified_for_an_op
         {
             var directoryInfo = new DirectoryInfo(Directory.GetCurrentDirectory());
 
-            var option = new Option<DirectoryInfo>("-x") { DefaultValueFactory = (_) => directoryInfo };
+            var option = new CliOption<DirectoryInfo>("-x") { DefaultValueFactory = (_) => directoryInfo };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -399,9 +399,9 @@ public void A_default_value_with_a_custom_constructor_can_be_specified_for_a_com
         {
             var directoryInfo = new DirectoryInfo(Directory.GetCurrentDirectory());
 
-            var argument = new Argument<DirectoryInfo>("the-arg") { DefaultValueFactory = (_) => directoryInfo };
+            var argument = new CliArgument<DirectoryInfo>("the-arg") { DefaultValueFactory = (_) => directoryInfo };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 argument
             };
@@ -418,9 +418,9 @@ public void A_default_value_with_a_custom_constructor_can_be_specified_for_a_com
         [Fact]
         public void Specifying_an_option_argument_overrides_the_default_value()
         {
-            var option = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var option = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
 
-            var command = new Command("something")
+            var command = new CliCommand("something")
             {
                 option
             };
@@ -436,7 +436,7 @@ public void Specifying_an_option_argument_overrides_the_default_value()
         [Fact]
         public void Values_can_be_correctly_converted_to_DateTime_without_the_parser_specifying_a_custom_converter()
         {
-            var option = new Option<DateTime>("-x");
+            var option = new CliOption<DateTime>("-x");
 
             var dateString = "2022-02-06T01:46:03.0000000-08:00";
 
@@ -447,7 +447,7 @@ public void Values_can_be_correctly_converted_to_DateTime_without_the_parser_spe
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_DateTime_without_the_parser_specifying_a_custom_converter()
         {
-            var option = new Option<DateTime?>("-x");
+            var option = new CliOption<DateTime?>("-x");
 
             var dateString = "2022-02-06T01:46:03.0000000-08:00";
 
@@ -457,7 +457,7 @@ public void Values_can_be_correctly_converted_to_nullable_DateTime_without_the_p
         [Fact]
         public void Values_can_be_correctly_converted_to_DateTimeOffset_without_the_parser_specifying_a_custom_converter()
         {
-            var option = new Option<DateTimeOffset>("-x");
+            var option = new CliOption<DateTimeOffset>("-x");
 
             var dateString = "2022-02-06T09:52:54.5275055-08:00";
 
@@ -467,7 +467,7 @@ public void Values_can_be_correctly_converted_to_DateTimeOffset_without_the_pars
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_DateTimeOffset_without_the_parser_specifying_a_custom_converter()
         {
-            var option = new Option<DateTimeOffset?>("-x");
+            var option = new CliOption<DateTimeOffset?>("-x");
 
             var dateString = "2022-02-06T09:52:54.5275055-08:00";
 
@@ -476,34 +476,34 @@ public void Values_can_be_correctly_converted_to_nullable_DateTimeOffset_without
 
         [Fact]
         public void Values_can_be_correctly_converted_to_decimal_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<decimal>("-x"), "-x 123.456").Should().Be(123.456m);
+            => GetValue(new CliOption<decimal>("-x"), "-x 123.456").Should().Be(123.456m);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_decimal_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<decimal?>("-x"), "-x 123.456").Should().Be(123.456m);
+            => GetValue(new CliOption<decimal?>("-x"), "-x 123.456").Should().Be(123.456m);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_double_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<double>("-x"), "-x 123.456").Should().Be(123.456d);
+            => GetValue(new CliOption<double>("-x"), "-x 123.456").Should().Be(123.456d);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_double_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<double?>("-x"), "-x 123.456").Should().Be(123.456d);
+            => GetValue(new CliOption<double?>("-x"), "-x 123.456").Should().Be(123.456d);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_float_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<float>("-x"), "-x 123.456").Should().Be(123.456f);
+            => GetValue(new CliOption<float>("-x"), "-x 123.456").Should().Be(123.456f);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_float_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<float?>("-x"), "-x 123.456").Should().Be(123.456f);
+            => GetValue(new CliOption<float?>("-x"), "-x 123.456").Should().Be(123.456f);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_Guid_without_the_parser_specifying_a_custom_converter()
         {
             const string guidString = "75517282-018F-46BB-B15F-1D8DBFE23F6E";
 
-            GetValue(new Option<Guid>("-x"), $"-x {guidString}").Should().Be(Guid.Parse(guidString));
+            GetValue(new CliOption<Guid>("-x"), $"-x {guidString}").Should().Be(Guid.Parse(guidString));
         }
 
         [Fact]
@@ -511,7 +511,7 @@ public void Values_can_be_correctly_converted_to_nullable_Guid_without_the_parse
         {
             const string guidString = "75517282-018F-46BB-B15F-1D8DBFE23F6E";
 
-            GetValue(new Option<Guid?>("-x"), $"-x {guidString}").Should().Be(Guid.Parse(guidString));
+            GetValue(new CliOption<Guid?>("-x"), $"-x {guidString}").Should().Be(Guid.Parse(guidString));
         }
 
         [Fact]
@@ -519,7 +519,7 @@ public void Values_can_be_correctly_converted_to_TimeSpan_without_the_parser_spe
         {
             const string timeSpanString = "30";
 
-            GetValue(new Option<TimeSpan>("-x"), $"-x {timeSpanString}").Should().Be(TimeSpan.Parse(timeSpanString));
+            GetValue(new CliOption<TimeSpan>("-x"), $"-x {timeSpanString}").Should().Be(TimeSpan.Parse(timeSpanString));
         }
 
         [Fact]
@@ -527,13 +527,13 @@ public void Values_can_be_correctly_converted_to_nullable_TimeSpan_without_the_p
         {
             const string timeSpanString = "30";
 
-            GetValue(new Option<TimeSpan?>("-x"), $"-x {timeSpanString}").Should().Be(TimeSpan.Parse(timeSpanString));
+            GetValue(new CliOption<TimeSpan?>("-x"), $"-x {timeSpanString}").Should().Be(TimeSpan.Parse(timeSpanString));
         }
 
         [Fact]
         public void Values_can_be_correctly_converted_to_Uri_when_custom_parser_is_provided()
         {
-            Option<Uri> option = new ("-x")
+            CliOption<Uri> option = new ("-x")
             {
                 CustomParser = (argumentResult) => Uri.TryCreate(argumentResult.Tokens.Last().Value, UriKind.RelativeOrAbsolute, out var uri) ? uri : null
             };
@@ -544,54 +544,54 @@ public void Values_can_be_correctly_converted_to_Uri_when_custom_parser_is_provi
         [Fact]
         public void Options_with_arguments_specified_can_be_correctly_converted_to_bool_without_the_parser_specifying_a_custom_converter()
         {
-            GetValue(new Option<bool>("-x"), "-x false").Should().BeFalse();
-            GetValue(new Option<bool>("-x"), "-x true").Should().BeTrue();
+            GetValue(new CliOption<bool>("-x"), "-x false").Should().BeFalse();
+            GetValue(new CliOption<bool>("-x"), "-x true").Should().BeTrue();
         }
 
         [Fact]
         public void Values_can_be_correctly_converted_to_long_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<long>("-x"), "-x 123456790").Should().Be(123456790L);
+            => GetValue(new CliOption<long>("-x"), "-x 123456790").Should().Be(123456790L);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_long_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<long?>("-x"), "-x 123456790").Should().Be(123456790L);
+            => GetValue(new CliOption<long?>("-x"), "-x 123456790").Should().Be(123456790L);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_short_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<short>("-s"), "-s 1234").Should().Be(1234);
+            => GetValue(new CliOption<short>("-s"), "-s 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_short_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<short?>("-s"), "-s 1234").Should().Be(1234);
+            => GetValue(new CliOption<short?>("-s"), "-s 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_ulong_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<ulong>("-x"), "-x 1234").Should().Be(1234);
+            => GetValue(new CliOption<ulong>("-x"), "-x 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_ulong_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<ulong?>("-x"), "-x 1234").Should().Be(1234);
+            => GetValue(new CliOption<ulong?>("-x"), "-x 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_ushort_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<ushort>("-s"), "-s 1234").Should().Be(1234);
+            => GetValue(new CliOption<ushort>("-s"), "-s 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_ushort_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<ushort?>("-s"), "-s 1234").Should().Be(1234);
+            => GetValue(new CliOption<ushort?>("-s"), "-s 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_sbyte_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<sbyte>("-us"), "-us 123").Should().Be(123);
+            => GetValue(new CliOption<sbyte>("-us"), "-us 123").Should().Be(123);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_sbyte_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<sbyte?>("-us"), "-us 123").Should().Be(123);
+            => GetValue(new CliOption<sbyte?>("-us"), "-us 123").Should().Be(123);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_ipaddress_when_custom_parser_is_provided()
         {
-            Option<IPAddress> option = new ("-us")
+            CliOption<IPAddress> option = new ("-us")
             { 
                 CustomParser = (argumentResult) => IPAddress.Parse(argumentResult.Tokens.Last().Value)
             };
@@ -603,7 +603,7 @@ public void Values_can_be_correctly_converted_to_ipaddress_when_custom_parser_is
         [Fact]
         public void Values_can_be_correctly_converted_to_ipendpoint_when_custom_parser_is_provided()
         {
-            Option<IPEndPoint> option = new("-us")
+            CliOption<IPEndPoint> option = new("-us")
             {
                 CustomParser = (argumentResult) => IPEndPoint.Parse(argumentResult.Tokens.Last().Value)
             };
@@ -615,40 +615,40 @@ public void Values_can_be_correctly_converted_to_ipendpoint_when_custom_parser_i
 #if NET6_0_OR_GREATER
         [Fact]
         public void Values_can_be_correctly_converted_to_dateonly_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<DateOnly>("-us"), "-us 2022-03-02").Should().Be(DateOnly.Parse("2022-03-02"));
+            => GetValue(new CliOption<DateOnly>("-us"), "-us 2022-03-02").Should().Be(DateOnly.Parse("2022-03-02"));
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_dateonly_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<DateOnly?>("-x"), "-x 2022-03-02").Should().Be(DateOnly.Parse("2022-03-02"));
+            => GetValue(new CliOption<DateOnly?>("-x"), "-x 2022-03-02").Should().Be(DateOnly.Parse("2022-03-02"));
 
         [Fact]
         public void Values_can_be_correctly_converted_to_timeonly_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<TimeOnly>("-us"), "-us 12:34:56").Should().Be(TimeOnly.Parse("12:34:56"));
+            => GetValue(new CliOption<TimeOnly>("-us"), "-us 12:34:56").Should().Be(TimeOnly.Parse("12:34:56"));
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_timeonly_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<TimeOnly?>("-x"), "-x 12:34:56").Should().Be(TimeOnly.Parse("12:34:56"));
+            => GetValue(new CliOption<TimeOnly?>("-x"), "-x 12:34:56").Should().Be(TimeOnly.Parse("12:34:56"));
 #endif
 
         [Fact]
         public void Values_can_be_correctly_converted_to_byte_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<byte>("-us"), "-us 123").Should().Be(123);
+            => GetValue(new CliOption<byte>("-us"), "-us 123").Should().Be(123);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_byte_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<byte?>("-us"), "-us 123").Should().Be(123);
+            => GetValue(new CliOption<byte?>("-us"), "-us 123").Should().Be(123);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_uint_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<uint>("-us"), "-us 1234").Should().Be(1234);
+            => GetValue(new CliOption<uint>("-us"), "-us 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_nullable_uint_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<uint?>("-us"), "-us 1234").Should().Be(1234);
+            => GetValue(new CliOption<uint?>("-us"), "-us 1234").Should().Be(1234);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_array_of_int_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<int[]>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(1, 2, 3);
+            => GetValue(new CliOption<int[]>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(1, 2, 3);
 
         [Theory]
         [InlineData(0, 100_000, typeof(string[]))]
@@ -680,7 +680,7 @@ public void Values_can_be_correctly_converted_to_array_of_int_without_the_parser
             var option = OptionBuilder.CreateOption("--items", valueType: argumentType);
             option.Arity = new ArgumentArity(minArity, maxArity);
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 option
             };
@@ -693,26 +693,26 @@ public void Values_can_be_correctly_converted_to_array_of_int_without_the_parser
 
         [Fact]
         public void Values_can_be_correctly_converted_to_List_of_int_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<List<int>>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(1, 2, 3);
+            => GetValue(new CliOption<List<int>>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(1, 2, 3);
 
         [Fact]
         public void Values_can_be_correctly_converted_to_IEnumerable_of_int_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<IEnumerable<int>>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(1, 2, 3);
+            => GetValue(new CliOption<IEnumerable<int>>("-x"), "-x 1 -x 2 -x 3").Should().BeEquivalentTo(1, 2, 3);
 
         [Fact]
         public void Enum_values_can_be_correctly_converted_based_on_enum_value_name_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<DayOfWeek>("-x"), "-x Monday").Should().Be(DayOfWeek.Monday);
+            => GetValue(new CliOption<DayOfWeek>("-x"), "-x Monday").Should().Be(DayOfWeek.Monday);
 
         [Fact]
         public void Nullable_enum_values_can_be_correctly_converted_based_on_enum_value_name_without_the_parser_specifying_a_custom_converter()
-            => GetValue(new Option<DayOfWeek?>("-x"), "-x Monday").Should().Be(DayOfWeek.Monday);
+            => GetValue(new CliOption<DayOfWeek?>("-x"), "-x Monday").Should().Be(DayOfWeek.Monday);
 
         [Fact]
         public void Enum_values_that_cannot_be_parsed_result_in_an_informative_error()
         {
-            var option = new Option<DayOfWeek>("-x");
+            var option = new CliOption<DayOfWeek>("-x");
 
-            var value = new RootCommand { option }.Parse("-x Notaday");
+            var value = new CliRootCommand { option }.Parse("-x Notaday");
 
             value.Errors
                  .Should()
@@ -726,9 +726,9 @@ public void Enum_values_that_cannot_be_parsed_result_in_an_informative_error()
         [Fact]
         public void When_getting_a_single_value_and_specifying_a_conversion_type_that_is_not_supported_then_it_throws()
         {
-            var option = new Option<int>("-x");
+            var option = new CliOption<int>("-x");
 
-            var result = new RootCommand { option }.Parse("-x not-an-int");
+            var result = new CliRootCommand { option }.Parse("-x not-an-int");
 
             Action getValue = () => result.GetValue(option);
 
@@ -743,7 +743,7 @@ public void When_getting_a_single_value_and_specifying_a_conversion_type_that_is
         [Fact]
         public void When_getting_an_array_of_values_and_specifying_a_conversion_type_that_is_not_supported_then_it_throws()
         {
-            Action getValue = () => GetValue(new Option<int[]>("-x"), "-x not-an-int -x 2");
+            Action getValue = () => GetValue(new CliOption<int[]>("-x"), "-x not-an-int -x 2");
 
             getValue.Should()
                     .Throw<InvalidOperationException>()
@@ -756,7 +756,7 @@ public void When_getting_an_array_of_values_and_specifying_a_conversion_type_tha
         [Fact]
         public void String_defaults_to_null_when_not_specified_only_for_not_required_arguments()
             => GetValue(
-                new Argument<string>("arg")
+                new CliArgument<string>("arg")
                 { 
                     Arity = ArgumentArity.ZeroOrMore
                 }, "").Should().BeNull();
@@ -779,12 +779,12 @@ public void String_defaults_to_null_when_not_specified_only_for_not_required_arg
         [InlineData(typeof(FileAccess[]))]
         public void Sequence_type_defaults_to_empty_when_not_specified(Type sequenceType)
         {
-            var argument = Activator.CreateInstance(typeof(Argument<>).MakeGenericType(sequenceType), new object[] { "argName" });
+            var argument = Activator.CreateInstance(typeof(CliArgument<>).MakeGenericType(sequenceType), new object[] { "argName" });
 
             AssertParsedValueIsEmpty((dynamic)argument);
         }
 
-        private void AssertParsedValueIsEmpty<T>(Argument<T> argument) where T : IEnumerable
+        private void AssertParsedValueIsEmpty<T>(CliArgument<T> argument) where T : IEnumerable
             => GetValue(argument, "").Should().BeEmpty();
     }
 }
\ No newline at end of file
diff --git a/src/System.CommandLine.Tests/CommandLineConfigurationTests.cs b/src/System.CommandLine.Tests/CommandLineConfigurationTests.cs
index 24965cf588..bd89f37d95 100644
--- a/src/System.CommandLine.Tests/CommandLineConfigurationTests.cs
+++ b/src/System.CommandLine.Tests/CommandLineConfigurationTests.cs
@@ -11,11 +11,11 @@ public class CommandLineConfigurationTests
     [Fact]
     public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_option_aliases_on_the_root_command()
     {
-        var option1 = new Option<string>("--dupe");
-        var option2 = new Option<string>("-y");
+        var option1 = new CliOption<string>("--dupe");
+        var option2 = new CliOption<string>("-y");
         option2.Aliases.Add("--dupe");
 
-        var command = new RootCommand
+        var command = new CliRootCommand
         {
             option1,
             option2
@@ -36,13 +36,13 @@ public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_option_aliases_
     [Fact]
     public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_option_aliases_on_a_subcommand()
     {
-        var option1 = new Option<string>("--dupe");
-        var option2 = new Option<string>("--ok");
+        var option1 = new CliOption<string>("--dupe");
+        var option2 = new CliOption<string>("--ok");
         option2.Aliases.Add("--dupe");
 
-        var command = new RootCommand
+        var command = new CliRootCommand
         {
-            new Command("subcommand")
+            new CliCommand("subcommand")
             {
                 option1,
                 option2
@@ -64,11 +64,11 @@ public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_option_aliases_
     [Fact]
     public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_subcommand_aliases_on_the_root_command()
     {
-        var command1 = new Command("dupe");
-        var command2 = new Command("not-a-dupe");
+        var command1 = new CliCommand("dupe");
+        var command2 = new CliCommand("not-a-dupe");
         command2.Aliases.Add("dupe");
 
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
             command1,
             command2
@@ -89,12 +89,12 @@ public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_subcommand_alia
     [Fact]
     public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_subcommand_aliases_on_a_subcommand()
     {
-        var command = new RootCommand
+        var command = new CliRootCommand
         {
-            new Command("subcommand")
+            new CliCommand("subcommand")
             {
-                new Command("dupe"),
-                new Command("not-a-dupe") { Aliases = { "dupe" } }
+                new CliCommand("dupe"),
+                new CliCommand("not-a-dupe") { Aliases = { "dupe" } }
             }
         };
 
@@ -113,11 +113,11 @@ public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_subcommand_alia
     [Fact]
     public void ThrowIfInvalid_throws_if_sibling_command_and_option_aliases_collide_on_the_root_command()
     {
-        var option = new Option<string>("dupe");
-        var command = new Command("not-a-dupe");
+        var option = new CliOption<string>("dupe");
+        var command = new CliCommand("not-a-dupe");
         command.Aliases.Add("dupe");
 
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
             option,
             command
@@ -138,13 +138,13 @@ public void ThrowIfInvalid_throws_if_sibling_command_and_option_aliases_collide_
     [Fact]
     public void ThrowIfInvalid_throws_if_sibling_command_and_option_aliases_collide_on_a_subcommand()
     {
-        var option = new Option<string>("dupe");
-        var command = new Command("not-a-dupe");
+        var option = new CliOption<string>("dupe");
+        var command = new CliCommand("not-a-dupe");
         command.Aliases.Add("dupe");
 
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
-            new Command("subcommand")
+            new CliCommand("subcommand")
             {
                 option,
                 command
@@ -166,11 +166,11 @@ public void ThrowIfInvalid_throws_if_sibling_command_and_option_aliases_collide_
     [Fact]
     public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_global_option_aliases_on_the_root_command()
     {
-        var option1 = new Option<string>("--dupe") { AppliesToSelfAndChildren = true };
-        var option2 = new Option<string>("-y") { AppliesToSelfAndChildren = true };
+        var option1 = new CliOption<string>("--dupe") { Recursive = true };
+        var option2 = new CliOption<string>("-y") { Recursive = true };
         option2.Aliases.Add("--dupe");
 
-        var command = new RootCommand();
+        var command = new CliRootCommand();
         command.Options.Add(option1);
         command.Options.Add(option2);
 
@@ -189,14 +189,14 @@ public void ThrowIfInvalid_throws_if_there_are_duplicate_sibling_global_option_a
     [Fact]
     public void ThrowIfInvalid_does_not_throw_if_global_option_alias_is_the_same_as_local_option_alias()
     {
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
-            new Command("subcommand")
+            new CliCommand("subcommand")
             {
-                new Option<string>("--dupe")
+                new CliOption<string>("--dupe")
             }
         };
-        rootCommand.Options.Add(new Option<string>("--dupe") { AppliesToSelfAndChildren = true });
+        rootCommand.Options.Add(new CliOption<string>("--dupe") { Recursive = true });
 
         var config = new CommandLineConfiguration(rootCommand);
 
@@ -208,14 +208,14 @@ public void ThrowIfInvalid_does_not_throw_if_global_option_alias_is_the_same_as_
     [Fact]
     public void ThrowIfInvalid_does_not_throw_if_global_option_alias_is_the_same_as_subcommand_alias()
     {
-        var rootCommand = new RootCommand
+        var rootCommand = new CliRootCommand
         {
-            new Command("subcommand")
+            new CliCommand("subcommand")
             {
-                new Command("--dupe")
+                new CliCommand("--dupe")
             }
         };
-        rootCommand.Options.Add(new Option<string>("--dupe") { AppliesToSelfAndChildren = true });
+        rootCommand.Options.Add(new CliOption<string>("--dupe") { Recursive = true });
 
         var config = new CommandLineConfiguration(rootCommand);
 
@@ -227,7 +227,7 @@ public void ThrowIfInvalid_does_not_throw_if_global_option_alias_is_the_same_as_
     [Fact]
     public void ThrowIfInvalid_throws_if_a_command_is_its_own_parent()
     {
-        var command = new RootCommand();
+        var command = new CliRootCommand();
         command.Add(command);
 
         var config = new CommandLineConfiguration(command);
@@ -245,8 +245,8 @@ public void ThrowIfInvalid_throws_if_a_command_is_its_own_parent()
     [Fact]
     public void ThrowIfInvalid_throws_if_a_parentage_cycle_is_detected()
     {
-        var command = new Command("command");
-        var rootCommand = new RootCommand { command };
+        var command = new CliCommand("command");
+        var rootCommand = new CliRootCommand { command };
         command.Add(rootCommand);
 
         var config = new CommandLineConfiguration(rootCommand);
diff --git a/src/System.CommandLine.Tests/CommandTests.cs b/src/System.CommandLine.Tests/CommandTests.cs
index 6282ad5106..bcee545b12 100644
--- a/src/System.CommandLine.Tests/CommandTests.cs
+++ b/src/System.CommandLine.Tests/CommandTests.cs
@@ -10,15 +10,15 @@ namespace System.CommandLine.Tests
 {
     public class CommandTests
     {
-        private readonly Command _outerCommand;
+        private readonly CliCommand _outerCommand;
 
         public CommandTests()
         {
-            _outerCommand = new Command("outer")
+            _outerCommand = new CliCommand("outer")
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<string>("--option")
+                    new CliOption<string>("--option")
                 }
             };
         }
@@ -102,14 +102,14 @@ public void Inner_command_option_argument_is_identified_correctly()
         [Fact]
         public void Commands_at_multiple_levels_can_have_their_own_arguments()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Argument<string>("outer_arg")
+                new CliArgument<string>("outer_arg")
             };
             outer.Subcommands.Add(
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Argument<string[]>("inner_arg")
+                    new CliArgument<string[]>("inner_arg")
                 });
 
             var result = outer.Parse("outer arg1 inner arg2 arg3");
@@ -131,7 +131,7 @@ public void Commands_at_multiple_levels_can_have_their_own_arguments()
         [Fact]
         public void Aliases_is_aware_of_added_alias()
         {
-            var command = new Command("original");
+            var command = new CliCommand("original");
 
             command.Aliases.Add("added");
 
@@ -146,7 +146,7 @@ public void Aliases_is_aware_of_added_alias()
         public void When_a_command_is_created_with_an_alias_that_contains_whitespace_then_an_informative_error_is_returned(
             string alias)
         {
-            Action create = () => new Command(alias);
+            Action create = () => new CliCommand(alias);
 
             create.Should()
                   .Throw<ArgumentException>()
@@ -163,7 +163,7 @@ public void Aliases_is_aware_of_added_alias()
         public void When_a_command_alias_is_added_and_contains_whitespace_then_an_informative_error_is_returned(
             string alias)
         {
-            var command = new Command("-x");
+            var command = new CliCommand("-x");
 
             Action addAlias = () => command.Aliases.Add(alias);
 
@@ -189,13 +189,13 @@ public void Aliases_is_aware_of_added_alias()
         [InlineData("outer arg inner arg inner-er arg", "inner-er")]
         public void ParseResult_Command_identifies_innermost_command(string input, string expectedCommand)
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Command("inner-er")
+                    new CliCommand("inner-er")
                 },
-                new Command("sibling")
+                new CliCommand("sibling")
             };
 
             var result = outer.Parse(input);
@@ -206,7 +206,7 @@ public void ParseResult_Command_identifies_innermost_command(string input, strin
         [Fact]
         public void Commands_can_have_aliases()
         {
-            var command = new Command("this");
+            var command = new CliCommand("this");
             command.Aliases.Add("that");
             command.Name.Should().Be("this");
             command.Aliases.Should().BeEquivalentTo("that");
@@ -221,7 +221,7 @@ public void Commands_can_have_aliases()
         [Fact]
         public void RootCommand_can_have_aliases()
         {
-            var command = new RootCommand();
+            var command = new CliRootCommand();
             command.Aliases.Add("that");
             command.Aliases.Should().BeEquivalentTo("that");
             command.Aliases.Should().BeEquivalentTo("that");
@@ -235,10 +235,10 @@ public void RootCommand_can_have_aliases()
         [Fact]
         public void Subcommands_can_have_aliases()
         {
-            var subcommand = new Command("this");
+            var subcommand = new CliCommand("this");
             subcommand.Aliases.Add("that");
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 subcommand
             };
@@ -252,9 +252,9 @@ public void Subcommands_can_have_aliases()
         [Fact]
         public void It_retains_argument_name_when_it_is_provided()
         {
-            var command = new Command("-alias")
+            var command = new CliCommand("-alias")
             {
-                new Argument<bool>("arg")
+                new CliArgument<bool>("arg")
             };
 
             command.Arguments.Single().Name.Should().Be("arg");
@@ -263,8 +263,8 @@ public void It_retains_argument_name_when_it_is_provided()
         [Fact]
         public void AddGlobalOption_updates_Options_property()
         {
-            var option = new Option<string>("-x") { AppliesToSelfAndChildren = true };
-            var command = new Command("mycommand");
+            var option = new CliOption<string>("-x") { Recursive = true };
+            var command = new CliCommand("mycommand");
             command.Options.Add(option);
 
             command.Options
@@ -276,8 +276,8 @@ public void AddGlobalOption_updates_Options_property()
         [Fact]
         public void When_Options_is_referenced_before_a_global_option_is_added_then_adding_a_global_option_updates_the_Options_collection()
         {
-            var option = new Option<string>("-x");
-            var command = new Command("mycommand");
+            var option = new CliOption<string>("-x");
+            var command = new CliCommand("mycommand");
 
             // referencing command.Options here would reproduce the above bug before the fix
             // keeping it ensures the fix works and doesn't regress
@@ -285,7 +285,7 @@ public void When_Options_is_referenced_before_a_global_option_is_added_then_addi
                 .Should()
                 .BeEmpty();
 
-            option.AppliesToSelfAndChildren = true;
+            option.Recursive = true;
             command.Options.Add(option);
 
             command.Options
diff --git a/src/System.CommandLine.Tests/CompilationTests.cs b/src/System.CommandLine.Tests/CompilationTests.cs
index 2694e94e0a..0f625c1f66 100644
--- a/src/System.CommandLine.Tests/CompilationTests.cs
+++ b/src/System.CommandLine.Tests/CompilationTests.cs
@@ -23,7 +23,7 @@ public CompilationTests(ITestOutputHelper output)
     {
         _output = output;
 
-        _systemCommandLineDllPath = typeof(Command).Assembly.Location;
+        _systemCommandLineDllPath = typeof(CliCommand).Assembly.Location;
     }
 
     [ReleaseBuildOnlyTheory]
diff --git a/src/System.CommandLine.Tests/CompletionContextTests.cs b/src/System.CommandLine.Tests/CompletionContextTests.cs
index 09d805d6e1..de5e33c5ab 100644
--- a/src/System.CommandLine.Tests/CompletionContextTests.cs
+++ b/src/System.CommandLine.Tests/CompletionContextTests.cs
@@ -12,11 +12,11 @@ public class CompletionContextTests
         [Fact]
         public void CommandLineText_preserves_command_line_prior_to_splitting_when_complete_command_line_is_parsed()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Command("verb")
+                new CliCommand("verb")
                 {
-                    new Option<int>("-x")
+                    new CliOption<int>("-x")
                 }
             };
 
@@ -36,11 +36,11 @@ public void CommandLineText_preserves_command_line_prior_to_splitting_when_compl
         [Fact]
         public void CommandLineText_is_preserved_when_adjusting_position()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Command("verb")
+                new CliCommand("verb")
                 {
-                    new Option<int>("-x")
+                    new CliOption<int>("-x")
                 }
             };
 
@@ -56,11 +56,11 @@ public void CommandLineText_is_preserved_when_adjusting_position()
         [Fact]
         public void CommandLineText_is_unavailable_when_string_array_is_parsed()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Command("verb")
+                new CliCommand("verb")
                 {
-                    new Option<int>("-x")
+                    new CliOption<int>("-x")
                 }
             };
 
@@ -74,10 +74,10 @@ public void CommandLineText_is_unavailable_when_string_array_is_parsed()
         [Fact]
         public void When_position_is_unspecified_in_string_command_line_not_ending_with_a_space_then_it_returns_final_token()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--option1"),
-                new Option<string>("--option2")
+                new CliOption<string>("--option1"),
+                new CliOption<string>("--option2")
             };
 
             string textToMatch = command.Parse("the-command t")
@@ -90,10 +90,10 @@ public void When_position_is_unspecified_in_string_command_line_not_ending_with_
         [Fact]
         public void When_position_is_unspecified_in_string_command_line_ending_with_a_space_then_it_returns_empty()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--option1"),
-                new Option<string>("--option2")
+                new CliOption<string>("--option1"),
+                new CliOption<string>("--option2")
             };
 
             var commandLine = "the-command t";
@@ -109,14 +109,14 @@ public void When_position_is_unspecified_in_string_command_line_ending_with_a_sp
         [Fact]
         public void When_position_is_greater_than_input_length_in_a_string_command_line_then_it_returns_empty()
         {
-            Option<string> option1 = new ("--option1");
+            CliOption<string> option1 = new ("--option1");
             option1.AcceptOnlyFromAmong("apple", "banana", "cherry", "durian");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<string>("arg"),
+                new CliArgument<string>("arg"),
                 option1,
-                new Option<string>("--option2")
+                new CliOption<string>("--option2")
             };
 
             var textToMatch = command.Parse("the-command --option1 a")
@@ -131,10 +131,10 @@ public void When_position_is_greater_than_input_length_in_a_string_command_line_
         [Fact]
         public void When_position_is_unspecified_in_array_command_line_and_final_token_is_unmatched_then_it_returns_final_token()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--option1"),
-                new Option<string>("--option2")
+                new CliOption<string>("--option1"),
+                new CliOption<string>("--option2")
             };
 
             string textToMatch = command.Parse(new[] { "the-command", "opt" })
@@ -147,10 +147,10 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_i
         [Fact]
         public void When_position_is_unspecified_in_array_command_line_and_final_token_matches_an_command_then_it_returns_empty()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--option1"),
-                new Option<string>("--option2")
+                new CliOption<string>("--option1"),
+                new CliOption<string>("--option2")
             };
 
             string textToMatch = command.Parse(new[] { "the-command" })
@@ -163,10 +163,10 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_m
         [Fact]
         public void When_position_is_unspecified_in_array_command_line_and_final_token_matches_an_option_then_it_returns_empty()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--option1"),
-                new Option<string>("--option2")
+                new CliOption<string>("--option1"),
+                new CliOption<string>("--option2")
             };
 
             string textToMatch = command.Parse(new[] { "the-command", "--option1" })
@@ -179,14 +179,14 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_m
         [Fact]
         public void When_position_is_unspecified_in_array_command_line_and_final_token_matches_an_argument_then_it_returns_the_argument_value()
         {
-            Option<string> option1 = new("--option1");
+            CliOption<string> option1 = new("--option1");
             option1.AcceptOnlyFromAmong("apple", "banana", "cherry", "durian");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option1,
-                new Option<string>("--option2"),
-                new Argument<string>("arg")
+                new CliOption<string>("--option2"),
+                new CliArgument<string>("arg")
             };
 
             string textToMatch = command.Parse(new[] { "the-command", "--option1", "a" })
@@ -208,9 +208,9 @@ public void When_position_is_unspecified_in_array_command_line_and_final_token_m
             string expected)
         {
             var command =
-                new Command("the-command")
+                new CliCommand("the-command")
                 {
-                    new Argument<string[]>("arg")
+                    new CliArgument<string[]>("arg")
                 };
 
             var position = commandLine.IndexOf("$", StringComparison.Ordinal);
diff --git a/src/System.CommandLine.Tests/CompletionTests.cs b/src/System.CommandLine.Tests/CompletionTests.cs
index a8fc5177a3..e98d307a7a 100644
--- a/src/System.CommandLine.Tests/CompletionTests.cs
+++ b/src/System.CommandLine.Tests/CompletionTests.cs
@@ -25,7 +25,7 @@ public CompletionTests(ITestOutputHelper output)
         [Fact]
         public void Option_GetCompletions_returns_argument_completions_if_configured()
         {
-            var option = new Option<string>("--hello");
+            var option = new CliOption<string>("--hello");
             option.CompletionSources.Add("one", "two", "three");
 
             var completions = option.GetCompletions(CompletionContext.Empty);
@@ -39,11 +39,11 @@ public void Option_GetCompletions_returns_argument_completions_if_configured()
         [Fact]
         public void Command_GetCompletions_returns_available_option_aliases()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Option<string>("--one") { Description = "option one" },
-                new Option<string>("--two") { Description = "option two" },
-                new Option<string>("--three") { Description = "option three" },
+                new CliOption<string>("--one") { Description = "option one" },
+                new CliOption<string>("--two") { Description = "option two" },
+                new CliOption<string>("--three") { Description = "option three" },
             };
 
             var completions = command.GetCompletions(CompletionContext.Empty);
@@ -57,26 +57,26 @@ public void Command_GetCompletions_returns_available_option_aliases()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1563
         public void Command_GetCompletions_returns_available_option_aliases_for_global_options()
         {
-            var subcommand2 = new Command("command2")
+            var subcommand2 = new CliCommand("command2")
             {
-                new Option<string>("--one") { Description = "option one" },
-                new Option<string>("--two") { Description = "option two" }
+                new CliOption<string>("--one") { Description = "option one" },
+                new CliOption<string>("--two") { Description = "option two" }
             };
 
-            var subcommand1 = new Command("command1")
+            var subcommand1 = new CliCommand("command1")
             {
                 subcommand2
             };
 
-            var rootCommand = new Command("root")
+            var rootCommand = new CliCommand("root")
             {
                 subcommand1
             };
 
-            rootCommand.Options.Add(new Option<string>("--three") 
+            rootCommand.Options.Add(new CliOption<string>("--three") 
             { 
                 Description = "option three",
-                AppliesToSelfAndChildren = true
+                Recursive = true
             });
 
             var completions = subcommand2.GetCompletions(CompletionContext.Empty);
@@ -90,11 +90,11 @@ public void Command_GetCompletions_returns_available_option_aliases_for_global_o
         [Fact]
         public void Command_GetCompletions_returns_available_subcommands()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Command("one"),
-                new Command("two"),
-                new Command("three")
+                new CliCommand("one"),
+                new CliCommand("two"),
+                new CliCommand("three")
             };
 
             var completions = command.GetCompletions(CompletionContext.Empty);
@@ -108,10 +108,10 @@ public void Command_GetCompletions_returns_available_subcommands()
         [Fact]
         public void Command_GetCompletions_returns_available_subcommands_and_option_aliases()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Command("subcommand"),
-                new Option<string>("--option")
+                new CliCommand("subcommand"),
+                new CliOption<string>("--option")
             };
 
             var completions = command.GetCompletions(CompletionContext.Empty);
@@ -124,11 +124,11 @@ public void Command_GetCompletions_returns_available_subcommands_and_option_alia
         [Fact]
         public void Command_GetCompletions_returns_available_subcommands_and_option_aliases_and_configured_arguments()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Command("subcommand", "subcommand"),
-                new Option<bool>("--option") { Description = "option" },
-                new Argument<string[]>("args")
+                new CliCommand("subcommand", "subcommand"),
+                new CliOption<bool>("--option") { Description = "option" },
+                new CliArgument<string[]>("args")
                 {
                     Arity = ArgumentArity.OneOrMore,
                     CompletionSources = { "command-argument" }
@@ -145,11 +145,11 @@ public void Command_GetCompletions_returns_available_subcommands_and_option_alia
         [Fact]
         public void Command_GetCompletions_without_text_to_match_orders_alphabetically()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Command("andmythirdsubcommand"),
-                new Command("mysubcommand"),
-                new Command("andmyothersubcommand"),
+                new CliCommand("andmythirdsubcommand"),
+                new CliCommand("mysubcommand"),
+                new CliCommand("andmyothersubcommand"),
             };
 
             var completions = command.GetCompletions(CompletionContext.Empty);
@@ -163,9 +163,9 @@ public void Command_GetCompletions_without_text_to_match_orders_alphabetically()
         [Fact]
         public void Command_GetCompletions_does_not_return_argument_names()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Argument<string>("the-argument")
+                new CliArgument<string>("the-argument")
             };
 
             var completions = command.GetCompletions(CompletionContext.Empty);
@@ -179,11 +179,11 @@ public void Command_GetCompletions_does_not_return_argument_names()
         [Fact]
         public void Command_GetCompletions_with_text_to_match_orders_by_match_position_then_alphabetically()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Command("andmythirdsubcommand"),
-                new Command("mysubcommand"),
-                new Command("andmyothersubcommand"),
+                new CliCommand("andmythirdsubcommand"),
+                new CliCommand("mysubcommand"),
+                new CliCommand("andmyothersubcommand"),
             };
 
             CommandLineConfiguration simpleConfig = new (command);
@@ -198,11 +198,11 @@ public void Command_GetCompletions_with_text_to_match_orders_by_match_position_t
         [Fact]
         public void When_an_option_has_a_default_value_it_will_still_be_suggested()
         {
-            var command = new Command("test")
+            var command = new CliCommand("test")
             {
-                new Option<string>("--apple") { DefaultValueFactory = (_) => "cortland" },
-                new Option<string>("--banana"),
-                new Option<string>("--cherry")
+                new CliOption<string>("--apple") { DefaultValueFactory = (_) => "cortland" },
+                new CliOption<string>("--banana"),
+                new CliOption<string>("--cherry")
             };
 
             CommandLineConfiguration simpleConfig = new (command);
@@ -221,8 +221,8 @@ public void When_an_option_has_a_default_value_it_will_still_be_suggested()
         [Fact]
         public void Command_GetCompletions_can_access_ParseResult()
         {
-            var originOption = new Option<string>("--origin");
-            var cloneOption = new Option<string>("--clone");
+            var originOption = new CliOption<string>("--origin");
+            var cloneOption = new CliOption<string>("--clone");
 
             cloneOption.CompletionSources.Add(ctx =>
             {
@@ -230,7 +230,7 @@ public void Command_GetCompletions_can_access_ParseResult()
                 return !string.IsNullOrWhiteSpace(opt1Value) ? new[] { opt1Value } : Array.Empty<string>();
             });
 
-            RootCommand rootCommand = new RootCommand
+            CliRootCommand rootCommand = new CliRootCommand
             {
                 originOption,
                 cloneOption
@@ -250,11 +250,11 @@ public void Command_GetCompletions_can_access_ParseResult()
         [Fact]
         public void When_one_option_has_been_specified_then_it_and_its_siblings_will_still_be_suggested()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Option<string>("--apple"),
-                new Option<string>("--banana"),
-                new Option<string>("--cherry")
+                new CliOption<string>("--apple"),
+                new CliOption<string>("--banana"),
+                new CliOption<string>("--cherry")
             };
 
             var commandLine = "--apple grannysmith";
@@ -271,19 +271,19 @@ public void When_one_option_has_been_specified_then_it_and_its_siblings_will_sti
         [Fact]
         public void When_a_subcommand_has_been_specified_then_its_sibling_commands_will_not_be_suggested()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
-                new Command("apple")
+                new CliCommand("apple")
                 {
-                    new Option<string>("--cortland")
+                    new CliOption<string>("--cortland")
                 },
-                new Command("banana")
+                new CliCommand("banana")
                 {
-                    new Option<string>("--cavendish")
+                    new CliOption<string>("--cavendish")
                 },
-                new Command("cherry")
+                new CliCommand("cherry")
                 {
-                    new Option<string>("--rainier")
+                    new CliOption<string>("--rainier")
                 }
             };
             CommandLineConfiguration simpleConfig = new (rootCommand);
@@ -298,19 +298,19 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_commands_will_
         [Fact]
         public void When_a_subcommand_has_been_specified_then_its_sibling_commands_aliases_will_not_be_suggested()
         {
-            var apple = new Command("apple")
+            var apple = new CliCommand("apple")
             {
-                new Option<string>("--cortland")
+                new CliOption<string>("--cortland")
             };
             apple.Aliases.Add("apl");
 
-            var banana = new Command("banana")
+            var banana = new CliCommand("banana")
             {
-                new Option<string>("--cavendish")
+                new CliOption<string>("--cavendish")
             };
             banana.Aliases.Add("bnn");
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 apple,
                 banana
@@ -328,10 +328,10 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_commands_alias
         [Fact] // https://github.com/dotnet/command-line-api/issues/1494
         public void When_a_subcommand_has_been_specified_then_its_sibling_options_will_not_be_suggested()
         {
-            var command = new RootCommand("parent")
+            var command = new CliRootCommand("parent")
             {
-                new Command("child"), 
-                new Option<string>("--parent-option")
+                new CliCommand("child"), 
+                new CliOption<string>("--parent-option")
             };
 
             var commandLine = "child";
@@ -348,11 +348,11 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_options_will_n
         [Fact]
         public void When_a_subcommand_has_been_specified_then_its_sibling_options_with_argument_limit_reached_will_be_not_be_suggested()
         {
-            var command = new RootCommand("parent")
+            var command = new CliRootCommand("parent")
             {
-                new Command("child"),
-                new Option<string>("--parent-option"),
-                new Argument<string>("arg")
+                new CliCommand("child"),
+                new CliOption<string>("--parent-option"),
+                new CliArgument<string>("arg")
             };
 
             var commandLine = "--parent-option 123 child";
@@ -368,12 +368,12 @@ public void When_a_subcommand_has_been_specified_then_its_sibling_options_with_a
         [Fact]
         public void When_a_subcommand_has_been_specified_then_its_child_options_will_be_suggested()
         {
-            var command = new RootCommand("parent")
+            var command = new CliRootCommand("parent")
             {
-                new Argument<string>("arg"),
-                new Command("child")
+                new CliArgument<string>("arg"),
+                new CliCommand("child")
                 {
-                    new Option<string>("--child-option")
+                    new CliOption<string>("--child-option")
                 }
             };
 
@@ -391,19 +391,19 @@ public void When_a_subcommand_has_been_specified_then_its_child_options_will_be_
         [Fact]
         public void When_a_subcommand_with_subcommands_has_been_specified_then_its_sibling_commands_will_not_be_suggested()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
-                new Command("apple")
+                new CliCommand("apple")
                 {
-                    new Command("cortland")
+                    new CliCommand("cortland")
                 },
-                new Command("banana")
+                new CliCommand("banana")
                 {
-                    new Command("cavendish")
+                    new CliCommand("cavendish")
                 },
-                new Command("cherry")
+                new CliCommand("cherry")
                 {
-                    new Command("rainier")
+                    new CliCommand("rainier")
                 }
             };
 
@@ -420,11 +420,11 @@ public void When_a_subcommand_with_subcommands_has_been_specified_then_its_sibli
         [Fact]
         public void When_one_option_has_been_partially_specified_then_nonmatching_siblings_will_not_be_suggested()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--apple"),
-                new Option<string>("--banana"),
-                new Option<string>("--cherry")
+                new CliOption<string>("--apple"),
+                new CliOption<string>("--banana"),
+                new CliOption<string>("--cherry")
             };
 
             var input = "a";
@@ -441,13 +441,13 @@ public void When_one_option_has_been_partially_specified_then_nonmatching_siblin
         [Fact]
         public void An_option_can_be_hidden_from_completions_by_setting_IsHidden_to_true()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--hide-me")
+                new CliOption<string>("--hide-me")
                 {
-                    IsHidden = true
+                    Hidden = true
                 },
-                new Option<string>("-n") { Description = "Not hidden" }
+                new CliOption<string>("-n") { Description = "Not hidden" }
             };
 
             CommandLineConfiguration simpleConfig = new (command);
@@ -459,7 +459,7 @@ public void An_option_can_be_hidden_from_completions_by_setting_IsHidden_to_true
         [Fact]
         public void Parser_options_can_supply_context_sensitive_matches()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "--bread", "wheat", "sourdough", "rye"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "--cheese", "provolone", "cheddar", "cream cheese")
@@ -486,11 +486,11 @@ public void Parser_options_can_supply_context_sensitive_matches()
         [Fact]
         public void Subcommand_names_are_available_as_suggestions()
         {
-            var command = new Command("test")
+            var command = new CliCommand("test")
             {
-                new Command("one", "Command one"),
-                new Command("two", "Command two"),
-                new Argument<string>("arg")
+                new CliCommand("one", "Command one"),
+                new CliCommand("two", "Command two"),
+                new CliArgument<string>("arg")
             };
 
             var commandLine = "test";
@@ -505,11 +505,11 @@ public void Subcommand_names_are_available_as_suggestions()
         [Fact]
         public void Both_subcommands_and_options_are_available_as_suggestions()
         {
-            var command = new Command("test")
+            var command = new CliCommand("test")
             {
-                new Command("one"),
-                new Option<string>("--one"),
-                new Argument<string>("arg")
+                new CliCommand("one"),
+                new CliOption<string>("--one"),
+                new CliArgument<string>("arg")
             };
 
             var commandLine = "test";
@@ -526,11 +526,11 @@ public void Both_subcommands_and_options_are_available_as_suggestions()
         [InlineData("outer -")]
         public void Option_GetCompletions_are_not_provided_without_matching_prefix(string input)
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
-                new Option<string>("--one"),
-                new Option<string>("--two"),
-                new Option<string>("--three")
+                new CliOption<string>("--one"),
+                new CliOption<string>("--two"),
+                new CliOption<string>("--three")
             };
 
             CommandLineConfiguration simpleConfig = new (command);
@@ -544,11 +544,11 @@ public void Option_GetCompletions_are_not_provided_without_matching_prefix(strin
         [Fact]
         public void Option_GetCompletions_can_be_based_on_the_proximate_option()
         {
-            Command outer = new Command("outer")
+            CliCommand outer = new CliCommand("outer")
             {
-                new Option<string>("--one"),
-                new Option<string>("--two"),
-                new Option<string>("--three")
+                new CliOption<string>("--one"),
+                new CliOption<string>("--two"),
+                new CliOption<string>("--three")
             };
 
             var commandLine = "outer";
@@ -564,7 +564,7 @@ public void Option_GetCompletions_can_be_based_on_the_proximate_option()
         [Fact]
         public void Argument_completions_can_be_based_on_the_proximate_option()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "--one", "one-a", "one-b"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "--two", "two-a", "two-b")
@@ -583,11 +583,11 @@ public void Argument_completions_can_be_based_on_the_proximate_option()
         [Fact]
         public void Option_GetCompletions_can_be_based_on_the_proximate_option_and_partial_input()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Command("one", "Command one"),
-                new Command("two", "Command two"),
-                new Command("three", "Command three")
+                new CliCommand("one", "Command one"),
+                new CliCommand("two", "Command two"),
+                new CliCommand("three", "Command three")
             };
 
             CommandLineConfiguration simpleConfig = new (outer);
@@ -602,10 +602,10 @@ public void Option_GetCompletions_can_be_based_on_the_proximate_option_and_parti
         [Fact]
         public void Completions_can_be_provided_in_the_absence_of_validation()
         {
-            Option<string> option = new ("-t");
+            CliOption<string> option = new ("-t");
             option.CompletionSources.Add("vegetable", "mineral", "animal");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -627,11 +627,11 @@ public void Completions_can_be_provided_in_the_absence_of_validation()
         [Fact]
         public void Command_argument_completions_can_be_provided_using_a_delegate()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Command("one")
+                new CliCommand("one")
                 {
-                    new Argument<string>("arg")
+                    new CliArgument<string>("arg")
                         {
                             CompletionSources = { _ => new[] { "vegetable", "mineral", "animal" } }
                         }
@@ -648,10 +648,10 @@ public void Command_argument_completions_can_be_provided_using_a_delegate()
         [Fact]
         public void Option_argument_completions_can_be_provided_using_a_delegate()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
             option.CompletionSources.Add(_ => new[] { "vegetable", "mineral", "animal" });
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -668,7 +668,7 @@ public void Option_argument_completions_can_be_provided_using_a_delegate()
         [Fact]
         public void When_caller_does_the_tokenizing_then_argument_completions_are_based_on_the_proximate_option()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "one", "one-a", "one-b", "one-c"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "two", "two-a", "two-b", "two-c"),
@@ -688,7 +688,7 @@ public void When_caller_does_the_tokenizing_then_argument_completions_are_based_
         [Fact]
         public void When_parsing_from_array_then_argument_completions_are_based_on_the_proximate_option()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "one", "one-a", "one-b", "one-c"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "two", "two-a", "two-b", "two-c"),
@@ -706,17 +706,17 @@ public void When_parsing_from_array_then_argument_completions_are_based_on_the_p
         [Fact]
         public void When_parsing_from_text_then_argument_completions_are_based_on_the_proximate_command()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Command("one")
+                new CliCommand("one")
                 {
                     CreateArgumentWithAcceptOnlyFromAmong("one-a", "one-b", "one-c")
                 },
-                new Command("two")
+                new CliCommand("two")
                 {
                     CreateArgumentWithAcceptOnlyFromAmong("two-a", "two-b", "two-c")
                 },
-                new Command("three")
+                new CliCommand("three")
                 {
                     CreateArgumentWithAcceptOnlyFromAmong("three-a", "three-b", "three-c")
                 }
@@ -733,17 +733,17 @@ public void When_parsing_from_text_then_argument_completions_are_based_on_the_pr
         [Fact]
         public void When_parsing_from_array_then_argument_completions_are_based_on_the_proximate_command()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Command("one")
+                new CliCommand("one")
                 {
                     CreateArgumentWithAcceptOnlyFromAmong("one-a", "one-b", "one-c")
                 },
-                new Command("two")
+                new CliCommand("two")
                 {
                     CreateArgumentWithAcceptOnlyFromAmong("two-a", "two-b", "two-c")
                 },
-                new Command("three")
+                new CliCommand("three")
                 {
                     CreateArgumentWithAcceptOnlyFromAmong("three-a", "three-b", "three-c")
                 }
@@ -760,11 +760,11 @@ public void When_parsing_from_array_then_argument_completions_are_based_on_the_p
         [Fact] // https://github.com/dotnet/command-line-api/issues/1518
         public void When_parsing_from_text_if_the_proximate_option_is_completed_then_completions_consider_other_option_tokens()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "--framework", "net7.0"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "--language", "C#"),
-                new Option<string>("--langVersion")
+                new CliOption<string>("--langVersion")
             };
             var configuration = new CommandLineConfiguration(command);
             var completions = command.Parse("--framework net7.0 --l", configuration).GetCompletions();
@@ -777,11 +777,11 @@ public void When_parsing_from_text_if_the_proximate_option_is_completed_then_com
         [Fact] 
         public void When_parsing_from_array_if_the_proximate_option_is_completed_then_completions_consider_other_option_tokens()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 CreateOptionWithAcceptOnlyFromAmong(name: "--framework", "net7.0"),
                 CreateOptionWithAcceptOnlyFromAmong(name: "--language", "C#"),
-                new Option<string>("--langVersion")
+                new CliOption<string>("--langVersion")
             };
             var configuration = new CommandLineConfiguration(command);
             var completions = command.Parse(new[]{"--framework","net7.0","--l"}, configuration).GetCompletions();
@@ -794,9 +794,9 @@ public void When_parsing_from_array_if_the_proximate_option_is_completed_then_co
         [Fact]
         public void Arguments_of_type_enum_provide_enum_values_as_suggestions()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<FileMode>("arg")
+                new CliArgument<FileMode>("arg")
             };
 
             var completions = command.Parse("the-command create")
@@ -811,10 +811,10 @@ public void Arguments_of_type_enum_provide_enum_values_as_suggestions()
         [Fact]
         public void Options_that_have_been_specified_to_their_maximum_arity_are_not_suggested()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Option<string>("--allows-one"),
-                new Option<string[]>("--allows-many")
+                new CliOption<string>("--allows-one"),
+                new CliOption<string[]>("--allows-many")
             };
 
             var commandLine = "--allows-one x";
@@ -829,10 +829,10 @@ public void Options_that_have_been_specified_to_their_maximum_arity_are_not_sugg
         [Fact]
         public void When_current_symbol_is_an_option_that_requires_arguments_then_parent_symbol_completions_are_omitted()
         {
-            var configuration = new CommandLineConfiguration(new RootCommand
+            var configuration = new CommandLineConfiguration(new CliRootCommand
                          {
-                             new Option<string>("--allows-one"),
-                             new Option<string[]>("--allows-many")
+                             new CliOption<string>("--allows-one"),
+                             new CliOption<string[]>("--allows-many")
                          })
             {
                 Directives = { new SuggestDirective() } 
@@ -846,10 +846,10 @@ public void When_current_symbol_is_an_option_that_requires_arguments_then_parent
         [Fact]
         public void Option_substring_matching_when_arguments_have_default_values()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<string>("--implicit") { DefaultValueFactory = (_) => "the-default" },
-                new Option<string>("--not") { DefaultValueFactory = (_) => "the-default" }
+                new CliOption<string>("--implicit") { DefaultValueFactory = (_) => "the-default" },
+                new CliOption<string>("--not") { DefaultValueFactory = (_) => "the-default" }
             };
 
             var completions = command.Parse("m").GetCompletions();
@@ -871,10 +871,10 @@ public void It_can_provide_completions_within_quotes(string commandLine, int pos
                 "\"nuget:Microsoft.DotNet.Interactive\""
             };
 
-            var argument = new Argument<string>("arg");
+            var argument = new CliArgument<string>("arg");
             argument.CompletionSources.Add(expectedSuggestions);
 
-            var r = new Command("#r")
+            var r = new CliCommand("#r")
             {
                 argument
             };
@@ -892,10 +892,10 @@ public void It_can_provide_completions_within_quotes(string commandLine, int pos
         [Fact]
         public void Default_completions_can_be_cleared_and_replaced()
         {
-            var argument = new Argument<DayOfWeek>("day");
+            var argument = new CliArgument<DayOfWeek>("day");
             argument.CompletionSources.Clear();
             argument.CompletionSources.Add(new[] { "mon", "tues", "wed", "thur", "fri", "sat", "sun" });
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 argument
             };
@@ -911,9 +911,9 @@ public void Default_completions_can_be_cleared_and_replaced()
         [Fact]
         public void Default_completions_can_be_appended_to()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<DayOfWeek>("day")
+                new CliArgument<DayOfWeek>("day")
                 {
                     CompletionSources = { "mon", "tues", "wed", "thur", "fri", "sat", "sun" }
                 }
@@ -941,9 +941,9 @@ public void Default_completions_can_be_appended_to()
         public void Completions_for_options_provide_a_description()
         {
             var description = "The option before -y.";
-            var option = new Option<string>("-x") { Description = description };
+            var option = new CliOption<string>("-x") { Description = description };
 
-            var completions = new Command("test") { option }.GetCompletions(CompletionContext.Empty);
+            var completions = new CliCommand("test") { option }.GetCompletions(CompletionContext.Empty);
 
             completions.Should().ContainSingle()
                        .Which
@@ -956,9 +956,9 @@ public void Completions_for_options_provide_a_description()
         public void Completions_for_subcommands_provide_a_description()
         {
             var description = "The description for the subcommand";
-            var subcommand = new Command("-x", description);
+            var subcommand = new CliCommand("-x", description);
 
-            var completions = new Command("test") { subcommand }.GetCompletions(CompletionContext.Empty);
+            var completions = new CliCommand("test") { subcommand }.GetCompletions(CompletionContext.Empty);
 
             completions.Should().ContainSingle()
                        .Which
@@ -970,8 +970,8 @@ public void Completions_for_subcommands_provide_a_description()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1629
         public void When_option_completions_are_available_then_they_are_suggested_when_a_validation_error_occurs()
         {
-            Option<DayOfWeek> option = new ("--day");
-            RootCommand rootCommand = new () { option };
+            CliOption<DayOfWeek> option = new ("--day");
+            CliRootCommand rootCommand = new () { option };
             CommandLineConfiguration simpleConfig = new (rootCommand);
 
             var result = rootCommand.Parse("--day SleepyDay", simpleConfig);
@@ -986,16 +986,16 @@ public void When_option_completions_are_available_then_they_are_suggested_when_a
                       $"Cannot parse argument 'SleepyDay' for option '--day' as expected type 'System.DayOfWeek'. Did you mean one of the following?{NewLine}Friday{NewLine}Monday{NewLine}Saturday{NewLine}Sunday{NewLine}Thursday{NewLine}Tuesday{NewLine}Wednesday");
         }
 
-        private static Argument<string> CreateArgumentWithAcceptOnlyFromAmong(params string[] values)
+        private static CliArgument<string> CreateArgumentWithAcceptOnlyFromAmong(params string[] values)
         {
-            Argument<string> argument = new("arg");
+            CliArgument<string> argument = new("arg");
             argument.AcceptOnlyFromAmong(values);
             return argument;
         }
 
-        private static Option<string> CreateOptionWithAcceptOnlyFromAmong(string name, params string[] values)
+        private static CliOption<string> CreateOptionWithAcceptOnlyFromAmong(string name, params string[] values)
         {
-            Option<string> option = new(name);
+            CliOption<string> option = new(name);
             option.AcceptOnlyFromAmong(values);
             return option;
         }
diff --git a/src/System.CommandLine.Tests/DirectiveTests.cs b/src/System.CommandLine.Tests/DirectiveTests.cs
index 53d8bff8cc..1bce1f8138 100644
--- a/src/System.CommandLine.Tests/DirectiveTests.cs
+++ b/src/System.CommandLine.Tests/DirectiveTests.cs
@@ -13,9 +13,9 @@ public class DirectiveTests
         [Fact]
         public void Directives_should_be_considered_as_unmatched_tokens_when_they_are_not_matched()
         {
-            Directive directive = new("parse");
+            CliDirective directive = new("parse");
 
-            ParseResult result = Parse(new Option<bool>("-y"), directive, $"{RootCommand.ExecutableName} [nonExisting] -y");
+            ParseResult result = Parse(new CliOption<bool>("-y"), directive, $"{CliRootCommand.ExecutableName} [nonExisting] -y");
 
             result.UnmatchedTokens.Should().ContainSingle("[nonExisting]");
         }
@@ -23,9 +23,9 @@ public void Directives_should_be_considered_as_unmatched_tokens_when_they_are_no
         [Fact]
         public void Raw_tokens_still_hold_directives()
         {
-            Directive directive = new ("parse");
+            CliDirective directive = new ("parse");
 
-            ParseResult result = Parse(new Option<bool>("-y"), directive, "[parse] -y");
+            ParseResult result = Parse(new CliOption<bool>("-y"), directive, "[parse] -y");
 
             result.FindResultFor(directive).Should().NotBeNull();
             result.Tokens.Should().Contain(t => t.Value == "[parse]");
@@ -34,9 +34,9 @@ public void Raw_tokens_still_hold_directives()
         [Fact]
         public void Multiple_directives_are_allowed()
         {
-            RootCommand root = new() { new Option<bool>("-y") };
-            Directive parseDirective = new ("parse");
-            Directive suggestDirective = new ("suggest");
+            CliRootCommand root = new() { new CliOption<bool>("-y") };
+            CliDirective parseDirective = new ("parse");
+            CliDirective suggestDirective = new ("suggest");
             CommandLineConfiguration config = new(root);
             config.Directives.Add(parseDirective);
             config.Directives.Add(suggestDirective);
@@ -50,9 +50,9 @@ public void Multiple_directives_are_allowed()
         [Fact]
         public void Directives_must_be_the_first_argument()
         {
-            Directive directive = new("parse");
+            CliDirective directive = new("parse");
 
-            ParseResult result = Parse(new Option<bool>("-y"), directive, "-y [parse]");
+            ParseResult result = Parse(new CliOption<bool>("-y"), directive, "-y [parse]");
 
             result.FindResultFor(directive).Should().BeNull();
         }
@@ -66,9 +66,9 @@ public void Directives_must_be_the_first_argument()
             string key,
             string expectedValue)
         {
-            Directive directive = new(key);
+            CliDirective directive = new(key);
 
-            ParseResult result = Parse(new Option<bool>("-y"), directive, $"{wholeText} -y");
+            ParseResult result = Parse(new CliOption<bool>("-y"), directive, $"{wholeText} -y");
 
             result.FindResultFor(directive).Values.Single().Should().Be(expectedValue);
         }
@@ -76,9 +76,9 @@ public void Directives_must_be_the_first_argument()
         [Fact]
         public void Directives_without_a_value_specified_have_no_values()
         {
-            Directive directive = new("parse");
+            CliDirective directive = new("parse");
 
-            ParseResult result = Parse(new Option<bool>("-y"), directive, "[parse] -y");
+            ParseResult result = Parse(new CliOption<bool>("-y"), directive, "[parse] -y");
 
             result.FindResultFor(directive).Values.Should().BeEmpty();
         }
@@ -88,8 +88,8 @@ public void Directives_without_a_value_specified_have_no_values()
         [InlineData("[:value]")]
         public void Directives_must_have_a_non_empty_key(string directive)
         {
-            Option<bool> option = new ("-a");
-            RootCommand root = new () { option };
+            CliOption<bool> option = new ("-a");
+            CliRootCommand root = new () { option };
 
             var result = root.Parse($"{directive} -a");
 
@@ -102,11 +102,11 @@ public void Directives_must_have_a_non_empty_key(string directive)
         [InlineData("[parse ]", "[parse", "]")]
         public void Directives_cannot_contain_spaces(string value, string firstUnmatchedToken, string secondUnmatchedToken)
         {
-            Action create = () => new Directive(value);
+            Action create = () => new CliDirective(value);
             create.Should().Throw<ArgumentException>();
 
-            Directive directive = new("parse");
-            ParseResult result = Parse(new Option<bool>("-y"), directive, $"{value} -y");
+            CliDirective directive = new("parse");
+            ParseResult result = Parse(new CliOption<bool>("-y"), directive, $"{value} -y");
             result.FindResultFor(directive).Should().BeNull();
 
             result.UnmatchedTokens.Should().BeEquivalentTo(firstUnmatchedToken, secondUnmatchedToken);
@@ -115,16 +115,16 @@ public void Directives_cannot_contain_spaces(string value, string firstUnmatched
         [Fact]
         public void When_a_directive_is_specified_more_than_once_then_its_values_are_aggregated()
         {
-            Directive directive = new("directive");
+            CliDirective directive = new("directive");
 
-            ParseResult result = Parse(new Option<bool>("-a"), directive, "[directive:one] [directive:two] -a");
+            ParseResult result = Parse(new CliOption<bool>("-a"), directive, "[directive:one] [directive:two] -a");
 
             result.FindResultFor(directive).Values.Should().BeEquivalentTo("one", "two");
         }
 
-        private static ParseResult Parse(Option option, Directive directive, string commandLine)
+        private static ParseResult Parse(CliOption option, CliDirective directive, string commandLine)
         {
-            RootCommand root = new() { option };
+            CliRootCommand root = new() { option };
             CommandLineConfiguration config = new(root);
             config.Directives.Add(directive);
 
diff --git a/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs b/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs
index 870ab12b0c..53dcbe24be 100644
--- a/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/EnvironmentVariableDirectiveTests.cs
@@ -18,7 +18,7 @@ public async Task Sets_environment_variable_to_value()
             bool asserted = false;
             string variable = test_variable;
             const string value = "This is a test";
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
@@ -41,7 +41,7 @@ public async Task Trims_environment_variable_name()
             bool asserted = false;
             string variable = test_variable;
             const string value = "This is a test";
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
@@ -64,7 +64,7 @@ public async Task Trims_environment_variable_value()
             bool asserted = false;
             string variable = test_variable;
             const string value = "This is a test";
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
@@ -87,7 +87,7 @@ public async Task Sets_environment_variable_value_containing_equals_sign()
             bool asserted = false;
             string variable = test_variable;
             const string value = "This is = a test containing equals";
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
@@ -109,7 +109,7 @@ public async Task Ignores_environment_directive_without_equals_sign()
         {
             bool asserted = false;
             string variable = test_variable;
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
@@ -131,7 +131,7 @@ public static async Task Ignores_environment_directive_with_empty_variable_name(
         {
             bool asserted = false;
             string value = $"This is a test, random: {randomizer.Next()}";
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
@@ -154,7 +154,7 @@ public static async Task Ignores_environment_directive_with_whitespace_variable_
         {
             bool asserted = false;
             string value = $"This is a test, random: {randomizer.Next()}";
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) =>
             {
                 asserted = true;
diff --git a/src/System.CommandLine.Tests/GetValueByNameParserTests.cs b/src/System.CommandLine.Tests/GetValueByNameParserTests.cs
index a22f5d860e..944a7fd310 100644
--- a/src/System.CommandLine.Tests/GetValueByNameParserTests.cs
+++ b/src/System.CommandLine.Tests/GetValueByNameParserTests.cs
@@ -14,24 +14,24 @@ public GetValueByNameParserTests(ITestOutputHelper output) : base(output)
         {
         }
 
-        protected override T GetValue<T>(ParseResult parseResult, Option<T> option)
+        protected override T GetValue<T>(ParseResult parseResult, CliOption<T> option)
             => parseResult.GetValue<T>(option.Name);
 
-        protected override T GetValue<T>(ParseResult parseResult, Argument<T> argument)
+        protected override T GetValue<T>(ParseResult parseResult, CliArgument<T> argument)
             => parseResult.GetValue<T>(argument.Name);
 
         [Fact]
         public void In_case_of_argument_name_conflict_the_value_which_belongs_to_the_last_parsed_command_is_returned()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int>("arg"),
-                new Command("inner1")
+                new CliArgument<int>("arg"),
+                new CliCommand("inner1")
                 {
-                    new Argument<int>("arg"),
-                    new Command("inner2")
+                    new CliArgument<int>("arg"),
+                    new CliCommand("inner2")
                     {
-                        new Argument<int>("arg"),
+                        new CliArgument<int>("arg"),
                     }
                 }
             };
@@ -44,15 +44,15 @@ public void In_case_of_argument_name_conflict_the_value_which_belongs_to_the_las
         [Fact]
         public void In_case_of_option_name_conflict_the_value_which_belongs_to_the_last_parsed_command_is_returned()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Option<int>("--integer", "-i"),
-                new Command("inner1")
+                new CliOption<int>("--integer", "-i"),
+                new CliCommand("inner1")
                 {
-                    new Option<int>("--integer", "-i"),
-                    new Command("inner2")
+                    new CliOption<int>("--integer", "-i"),
+                    new CliCommand("inner2")
                     {
-                        new Option<int>("--integer", "-i")
+                        new CliOption<int>("--integer", "-i")
                     }
                 }
             };
@@ -65,9 +65,9 @@ public void In_case_of_option_name_conflict_the_value_which_belongs_to_the_last_
         [Fact]
         public void When_option_value_is_not_parsed_then_default_value_is_returned()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Option<int>("--integer", "-i")
+                new CliOption<int>("--integer", "-i")
             };
 
             ParseResult parseResult = command.Parse("");
@@ -78,9 +78,9 @@ public void When_option_value_is_not_parsed_then_default_value_is_returned()
         [Fact]
         public void When_optional_argument_is_not_parsed_then_default_value_is_returned()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int>("arg")
+                new CliArgument<int>("arg")
                 {
                     Arity = ArgumentArity.ZeroOrOne
                 }
@@ -94,11 +94,11 @@ public void When_optional_argument_is_not_parsed_then_default_value_is_returned(
         [Fact]
         public void When_required_option_value_is_not_parsed_then_an_exception_is_thrown()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Option<int>("--required")
+                new CliOption<int>("--required")
                 {
-                    IsRequired = true
+                    Required = true
                 }
             };
 
@@ -115,9 +115,9 @@ public void When_required_option_value_is_not_parsed_then_an_exception_is_thrown
         [Fact]
         public void When_required_argument_value_is_not_parsed_then_an_exception_is_thrown()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int>("required")
+                new CliArgument<int>("required")
                 {
                     Arity = ArgumentArity.ExactlyOne
                 }
@@ -137,7 +137,7 @@ public void When_required_argument_value_is_not_parsed_then_an_exception_is_thro
         public void When_non_existing_name_is_used_then_exception_is_thrown()
         {
             const string nonExistingName = "nonExisting";
-            Command command = new ("noSymbols");
+            CliCommand command = new ("noSymbols");
             ParseResult parseResult = command.Parse("");
 
             Action getRequired = () => parseResult.GetValue<int>(nonExistingName);
@@ -153,13 +153,13 @@ public void When_an_option_and_argument_use_same_name_on_the_same_level_of_the_t
         {
             const string sameName = "same";
 
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int>(sameName)
+                new CliArgument<int>(sameName)
                 {
                     Arity = ArgumentArity.ZeroOrOne
                 },
-                new Option<int>(sameName)
+                new CliOption<int>(sameName)
             };
 
             ParseResult parseResult = command.Parse("");
@@ -177,12 +177,12 @@ public void When_an_option_and_argument_use_same_name_on_different_levels_of_the
         {
             const string sameName = "same";
 
-            Command command = new("outer")
+            CliCommand command = new("outer")
             {
-                new Argument<int>(sameName),
-                new Command("inner")
+                new CliArgument<int>(sameName),
+                new CliCommand("inner")
                 {
-                    new Option<int>(sameName)
+                    new CliOption<int>(sameName)
                 }
             };
 
@@ -198,15 +198,15 @@ public void When_an_option_and_argument_use_same_name_on_different_levels_of_the
         {
             const string sameName = "same";
 
-            Command command = new("outer")
+            CliCommand command = new("outer")
             {
-                new Argument<int>(sameName)
+                new CliArgument<int>(sameName)
                 {
                     DefaultValueFactory = (_) => 123
                 },
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<int>(sameName)
+                    new CliOption<int>(sameName)
                     {
                         DefaultValueFactory = (_) => 456
                     }
@@ -223,9 +223,9 @@ public void When_an_option_and_argument_use_same_name_on_different_levels_of_the
         [Fact]
         public void T_can_be_casted_to_nullable_of_T()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int>("name")
+                new CliArgument<int>("name")
             };
 
             ParseResult parseResult = command.Parse("123");
@@ -236,9 +236,9 @@ public void T_can_be_casted_to_nullable_of_T()
         [Fact]
         public void Array_of_T_can_be_casted_to_ienumerable_of_T()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int[]>("name")
+                new CliArgument<int[]>("name")
             };
 
             ParseResult parseResult = command.Parse("1 2 3");
@@ -251,9 +251,9 @@ public void When_casting_is_not_allowed_an_exception_is_thrown()
         {
             const string Name = "name";
 
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Argument<int>(Name)
+                new CliArgument<int>(Name)
             };
 
             ParseResult parseResult = command.Parse("123");
@@ -269,11 +269,11 @@ static void Assert(Action invalidCast)
         [Fact]
         public void Parse_errors_have_precedence_over_type_mismatch()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Option<int>("--required")
+                new CliOption<int>("--required")
                 {
-                    IsRequired = true
+                    Required = true
                 }
             };
 
diff --git a/src/System.CommandLine.Tests/GetValueByNameTypeConversionTests.cs b/src/System.CommandLine.Tests/GetValueByNameTypeConversionTests.cs
index 11a6e81620..0b3c699971 100644
--- a/src/System.CommandLine.Tests/GetValueByNameTypeConversionTests.cs
+++ b/src/System.CommandLine.Tests/GetValueByNameTypeConversionTests.cs
@@ -4,15 +4,15 @@ namespace System.CommandLine.Tests
 {
     public class GetValueByNameTypeConversionTests : TypeConversionTests
     {
-        protected override T GetValue<T>(Argument<T> argument, string commandLine)
+        protected override T GetValue<T>(CliArgument<T> argument, string commandLine)
         {
-            var result = new RootCommand { argument }.Parse(commandLine);
+            var result = new CliRootCommand { argument }.Parse(commandLine);
             return result.GetValue<T>(argument.Name);
         }
 
-        protected override T GetValue<T>(Option<T> option, string commandLine)
+        protected override T GetValue<T>(CliOption<T> option, string commandLine)
         {
-            var result = new RootCommand { option }.Parse(commandLine);
+            var result = new CliRootCommand { option }.Parse(commandLine);
             return result.GetValue<T>(option.Name);
         }
     }
diff --git a/src/System.CommandLine.Tests/GlobalOptionTests.cs b/src/System.CommandLine.Tests/GlobalOptionTests.cs
index 653c88a834..b98ede727a 100644
--- a/src/System.CommandLine.Tests/GlobalOptionTests.cs
+++ b/src/System.CommandLine.Tests/GlobalOptionTests.cs
@@ -11,13 +11,13 @@ public class GlobalOptionTests
         [Fact]
         public void Global_options_appear_in_options_list()
         {
-            var root = new Command("parent");
+            var root = new CliCommand("parent");
 
-            var option = new Option<int>("--global") { AppliesToSelfAndChildren = true };
+            var option = new CliOption<int>("--global") { Recursive = true };
 
             root.Options.Add(option);
 
-            var child = new Command("child");
+            var child = new CliCommand("child");
 
             root.Subcommands.Add(child);
 
@@ -27,13 +27,13 @@ public void Global_options_appear_in_options_list()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1540
         public void When_a_required_global_option_is_omitted_it_results_in_an_error()
         {
-            var command = new Command("child");
-            var rootCommand = new RootCommand { command };
+            var command = new CliCommand("child");
+            var rootCommand = new CliRootCommand { command };
             command.SetAction((_) => { });
-            var requiredOption = new Option<bool>("--i-must-be-set")
+            var requiredOption = new CliOption<bool>("--i-must-be-set")
             {
-                IsRequired = true,
-                AppliesToSelfAndChildren = true
+                Required = true,
+                Recursive = true
             };
             rootCommand.Options.Add(requiredOption);
 
@@ -48,11 +48,11 @@ public void When_a_required_global_option_is_omitted_it_results_in_an_error()
         [Fact] 
         public void When_a_required_global_option_has_multiple_aliases_the_error_message_uses_the_name()
         {
-            var rootCommand = new RootCommand();
-            var requiredOption = new Option<bool>("-i", "--i-must-be-set")
+            var rootCommand = new CliRootCommand();
+            var requiredOption = new CliOption<bool>("-i", "--i-must-be-set")
             {
-                IsRequired = true,
-                AppliesToSelfAndChildren = true
+                Required = true,
+                Recursive = true
             };
             rootCommand.Options.Add(requiredOption);
 
@@ -67,13 +67,13 @@ public void When_a_required_global_option_has_multiple_aliases_the_error_message
         [Fact]
         public void When_a_required_global_option_is_present_on_child_of_command_it_was_added_to_it_does_not_result_in_an_error()
         {
-            var command = new Command("child");
-            var rootCommand = new RootCommand { command };
+            var command = new CliCommand("child");
+            var rootCommand = new CliRootCommand { command };
             command.SetAction((_) => { });
-            var requiredOption = new Option<bool>("--i-must-be-set")
+            var requiredOption = new CliOption<bool>("--i-must-be-set")
             {
-                IsRequired = true,
-                AppliesToSelfAndChildren = true
+                Required = true,
+                Recursive = true
             };
             rootCommand.Options.Add(requiredOption);
 
@@ -85,13 +85,13 @@ public void When_a_required_global_option_is_present_on_child_of_command_it_was_
         [Fact]
         public void Subcommands_added_after_a_global_option_is_added_to_parent_will_recognize_the_global_option()
         {
-            var root = new Command("parent");
+            var root = new CliCommand("parent");
 
-            var option = new Option<int>("--global") { AppliesToSelfAndChildren = true };
+            var option = new CliOption<int>("--global") { Recursive = true };
 
             root.Options.Add(option);
 
-            var child = new Command("child");
+            var child = new CliCommand("child");
 
             root.Subcommands.Add(child);
 
@@ -103,17 +103,17 @@ public void Subcommands_added_after_a_global_option_is_added_to_parent_will_reco
         [Fact]
         public void Subcommands_with_global_option_should_propagate_option_to_children()
         {
-            var root = new Command("parent");
+            var root = new CliCommand("parent");
             
-            var firstChild = new Command("first");
+            var firstChild = new CliCommand("first");
             
             root.Subcommands.Add(firstChild);
             
-            var option = new Option<int>("--global") { AppliesToSelfAndChildren = true };
+            var option = new CliOption<int>("--global") { Recursive = true };
             
             firstChild.Options.Add(option);
             
-            var secondChild = new Command("second");
+            var secondChild = new CliCommand("second");
             
             firstChild.Subcommands.Add(secondChild);
             
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderExtensions.cs b/src/System.CommandLine.Tests/Help/HelpBuilderExtensions.cs
index 202fb93453..0a2d532c6b 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderExtensions.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderExtensions.cs
@@ -10,7 +10,7 @@ public static class HelpBuilderExtensions
     {
         public static void Write(
             this HelpBuilder builder,
-            Command command,
+            CliCommand command,
             TextWriter writer) =>
             builder.Write(new HelpContext(builder, command, writer));
     }
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Approval.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Approval.cs
index abf70c8e8a..9055fbcb8f 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Approval.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Approval.cs
@@ -14,60 +14,60 @@ public partial class HelpBuilderTests
         [UseReporter(typeof(DiffReporter))]
         public void Help_layout_has_not_changed()
         {
-            var command = new Command("the-root-command", "Test description")
+            var command = new CliCommand("the-root-command", "Test description")
             {
-                new Argument<string>("the-root-arg-no-description-no-default"),
-                new Argument<string>("the-root-arg-no-description-default")
+                new CliArgument<string>("the-root-arg-no-description-no-default"),
+                new CliArgument<string>("the-root-arg-no-description-default")
                 {
                     DefaultValueFactory = (_) => "the-root-arg-no-description-default-value",
                 },
-                new Argument<string>("the-root-arg-no-default")
+                new CliArgument<string>("the-root-arg-no-default")
                 {
                     Description = "the-root-arg-no-default-description",
                 },
-                new Argument<string>("the-root-arg")
+                new CliArgument<string>("the-root-arg")
                 {
                     DefaultValueFactory = (_) => "the-root-arg-one-value",
                     Description = "the-root-arg-description"
                 },
-                new Argument<FileAccess>("the-root-arg-enum-default")
+                new CliArgument<FileAccess>("the-root-arg-enum-default")
                 {
                     DefaultValueFactory = (_) => FileAccess.Read,
                     Description = "the-root-arg-enum-default-description"
                 },
-                new Option<bool>("--the-root-option-no-arg", "-trna") 
+                new CliOption<bool>("--the-root-option-no-arg", "-trna") 
                 {
                     Description = "the-root-option-no-arg-description",
-                    IsRequired = true
+                    Required = true
                 },
-                new Option<string>("--the-root-option-no-description-default-arg", "-trondda")
+                new CliOption<string>("--the-root-option-no-description-default-arg", "-trondda")
                 {
                     DefaultValueFactory = (_) => "the-root-option--no-description-default-arg-value",
                 },
-                new Option<string>("--the-root-option-no-default-arg", "-tronda")
+                new CliOption<string>("--the-root-option-no-default-arg", "-tronda")
                 {
                     Description = "the-root-option-no-default-description",
                     HelpName = "the-root-option-arg-no-default-arg",
-                    IsRequired = true
+                    Required = true
                 },
-                new Option<string>("--the-root-option-default-arg", "-troda")
+                new CliOption<string>("--the-root-option-default-arg", "-troda")
                 {
                     DefaultValueFactory = (_) => "the-root-option-arg-value",
                     Description = "the-root-option-default-arg-description",
                     HelpName = "the-root-option-arg",
                 },
-                new Option<FileAccess>("--the-root-option-enum-arg", "-troea")
+                new CliOption<FileAccess>("--the-root-option-enum-arg", "-troea")
                 {
                     DefaultValueFactory = (_) => FileAccess.Read,
                     Description = "the-root-option-description",
                 },
-                new Option<FileAccess>("--the-root-option-required-enum-arg", "-trorea")
+                new CliOption<FileAccess>("--the-root-option-required-enum-arg", "-trorea")
                 {
                     DefaultValueFactory = (_) => FileAccess.Read,
                     Description = "the-root-option-description",
-                    IsRequired = true
+                    Required = true
                 },
-                new Option<bool>("--the-root-option-multi-line-description", "-tromld")
+                new CliOption<bool>("--the-root-option-multi-line-description", "-tromld")
                 {
                     Description = "the-root-option\r\nmulti-line\ndescription"
                 },
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
index 53b1789e47..289a26d4c1 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
@@ -33,8 +33,8 @@ public Customization()
             [Fact]
             public void Option_can_customize_displayed_default_value()
             {
-                var option = new Option<string>("--the-option") { DefaultValueFactory = _ => "not 42" };
-                var command = new Command("the-command", "command help")
+                var option = new CliOption<string>("--the-option") { DefaultValueFactory = _ => "not 42" };
+                var command = new CliCommand("the-command", "command help")
                 {
                     option
                 };
@@ -52,8 +52,8 @@ public void Option_can_customize_displayed_default_value()
             [Fact]
             public void Option_can_customize_first_column_text()
             {
-                var option = new Option<string>("--the-option") { Description = "option description" };
-                var command = new Command("the-command", "command help")
+                var option = new CliOption<string>("--the-option") { Description = "option description" };
+                var command = new CliCommand("the-command", "command help")
                 {
                     option
                 };
@@ -71,16 +71,16 @@ public void Option_can_customize_first_column_text()
             [Fact]
             public void Option_can_customize_first_column_text_based_on_parse_result()
             {
-                var option = new Option<bool>("option");
-                var commandA = new Command("a", "a command help")
+                var option = new CliOption<bool>("option");
+                var commandA = new CliCommand("a", "a command help")
                 {
                     option
                 };
-                var commandB = new Command("b", "b command help")
+                var commandB = new CliCommand("b", "b command help")
                 {
                     option
                 };
-                var command = new Command("root", "root command help")
+                var command = new CliCommand("root", "root command help")
                 {
                     commandA, commandB
                 };
@@ -117,16 +117,16 @@ public void Option_can_customize_first_column_text_based_on_parse_result()
             [Fact]
             public void Option_can_customize_second_column_text_based_on_parse_result()
             {
-                var option = new Option<bool>("option");
-                var commandA = new Command("a", "a command help")
+                var option = new CliOption<bool>("option");
+                var commandA = new CliCommand("a", "a command help")
                 {
                     option
                 };
-                var commandB = new Command("b", "b command help")
+                var commandB = new CliCommand("b", "b command help")
                 {
                     option
                 };
-                var command = new Command("root", "root command help")
+                var command = new CliCommand("root", "root command help")
                 {
                     commandA, commandB
                 };
@@ -162,8 +162,8 @@ public void Option_can_customize_second_column_text_based_on_parse_result()
             [Fact]
             public void Subcommand_can_customize_first_column_text()
             {
-                var subcommand = new Command("subcommand", "subcommand description");
-                var command = new Command("the-command", "command help")
+                var subcommand = new CliCommand("subcommand", "subcommand description");
+                var command = new CliCommand("the-command", "command help")
                 {
                     subcommand
                 };
@@ -181,8 +181,8 @@ public void Subcommand_can_customize_first_column_text()
             [Fact]
             public void Command_arguments_can_customize_first_column_text()
             {
-                var argument = new Argument<string>("arg-name") { Description = "arg description" };
-                var command = new Command("the-command", "command help")
+                var argument = new CliArgument<string>("arg-name") { Description = "arg description" };
+                var command = new CliCommand("the-command", "command help")
                 {
                     argument
                 };
@@ -200,12 +200,12 @@ public void Command_arguments_can_customize_first_column_text()
             [Fact]
             public void Command_arguments_can_customize_second_column_text()
             {
-                var argument = new Argument<string>("some-arg")
+                var argument = new CliArgument<string>("some-arg")
                 {
                     Description = "Default description",
                     DefaultValueFactory = _ => "not 42"
                 };
-                var command = new Command("the-command", "command help")
+                var command = new CliCommand("the-command", "command help")
                 {
                     argument
                 };
@@ -223,11 +223,11 @@ public void Command_arguments_can_customize_second_column_text()
             [Fact]
             public void Command_arguments_can_customize_default_value()
             {
-                var argument = new Argument<string>("some-arg")
+                var argument = new CliArgument<string>("some-arg")
                 {
                     DefaultValueFactory = (_) => "not 42"
                 };
-                var command = new Command("the-command", "command help")
+                var command = new CliCommand("the-command", "command help")
                 {
                     argument
                 };
@@ -257,8 +257,8 @@ public void Customize_throws_when_symbol_is_null()
             [InlineData(true, true, "custom 1st\\s*custom 2nd")]
             public void Option_can_fallback_to_default_when_customizing(bool conditionA, bool conditionB, string expected)
             {
-                var command = new Command("test");
-                var option = new Option<string>("--option") { Description = "description" };
+                var command = new CliCommand("test");
+                var option = new CliOption<string>("--option") { Description = "description" };
 
                 command.Options.Add(option);
 
@@ -297,8 +297,8 @@ public void Option_can_fallback_to_default_when_customizing(bool conditionA, boo
                 bool conditionC, 
                 string expected)
             {
-                var command = new Command("test");
-                var argument = new Argument<string>("arg")
+                var command = new CliCommand("test");
+                var argument = new CliArgument<string>("arg")
                 {
                     Description = "description",
                     DefaultValueFactory = _ => "default"
@@ -332,11 +332,11 @@ public void Option_can_fallback_to_default_when_customizing(bool conditionA, boo
             [Fact]
             public void Individual_symbols_can_be_customized()
             {
-                var subcommand = new Command("subcommand", "The default command description");
-                var option = new Option<int>("-x") { Description = "The default option description" };
-                var argument = new Argument<int>("int-value") { Description = "The default argument description" };
+                var subcommand = new CliCommand("subcommand", "The default command description");
+                var option = new CliOption<int>("-x") { Description = "The default option description" };
+                var argument = new CliArgument<int>("int-value") { Description = "The default argument description" };
 
-                var rootCommand = new RootCommand
+                var rootCommand = new CliRootCommand
                 {
                     subcommand,
                     option,
@@ -370,7 +370,7 @@ public void Individual_symbols_can_be_customized()
             [Fact]
             public void Help_sections_can_be_replaced()
             {
-                CommandLineConfiguration config = new(new RootCommand())
+                CommandLineConfiguration config = new(new CliRootCommand())
                 {
                     Output = new StringWriter()
                 };
@@ -397,7 +397,7 @@ IEnumerable<Action<HelpContext>> CustomLayout(HelpContext _)
             [Fact]
             public void Help_sections_can_be_supplemented()
             {
-                CommandLineConfiguration config = new(new RootCommand("hello"))
+                CommandLineConfiguration config = new(new CliRootCommand("hello"))
                 {
                     Output = new StringWriter(),
                 };
@@ -435,9 +435,9 @@ IEnumerable<Action<HelpContext>> CustomLayout(HelpContext _)
             public void Layout_can_be_composed_dynamically_based_on_context()
             {
                 HelpBuilder helpBuilder = new();
-                var commandWithTypicalHelp = new Command("typical");
-                var commandWithCustomHelp = new Command("custom");
-                var command = new RootCommand
+                var commandWithTypicalHelp = new CliCommand("typical");
+                var commandWithCustomHelp = new CliCommand("custom");
+                var command = new CliRootCommand
                 {
                     commandWithTypicalHelp,
                     commandWithCustomHelp
@@ -473,9 +473,9 @@ public void Layout_can_be_composed_dynamically_based_on_context()
             [Fact]
             public void Help_default_sections_can_be_wrapped()
             {
-                Command command = new("test")
+                CliCommand command = new("test")
                 {
-                    new Option<string>("--option")
+                    new CliOption<string>("--option")
                     {
                         Description = "option description",
                         HelpName = "option"
@@ -511,7 +511,7 @@ public void Help_default_sections_can_be_wrapped()
             [Fact]
             public void Help_customized_sections_can_be_wrapped()
             {
-                CommandLineConfiguration config = new(new RootCommand())
+                CommandLineConfiguration config = new(new CliRootCommand())
                 {
                     Output = new StringWriter()
                 };
@@ -535,7 +535,7 @@ IEnumerable<Action<HelpContext>> CustomLayout(HelpContext _)
                 }
             }
 
-            private string GetDefaultHelp(Command command, bool trimOneNewline = true)
+            private string GetDefaultHelp(CliCommand command, bool trimOneNewline = true)
             {
                 // The command might have already defined a HelpOption with custom settings,
                 // we need to overwrite it to get the actual defaults.
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
index 85e066af4f..629d430a70 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
@@ -30,7 +30,7 @@ public HelpBuilderTests()
             _helpBuilder = GetHelpBuilder(LargeMaxWidth);
             _columnPadding = new string(' ', ColumnGutterWidth);
             _indentation = new string(' ', IndentationWidth);
-            _executableName = RootCommand.ExecutableName;
+            _executableName = CliRootCommand.ExecutableName;
         }
 
         private HelpBuilder GetHelpBuilder(int maxWidth = SmallMaxWidth) => new(maxWidth);
@@ -40,7 +40,7 @@ public HelpBuilderTests()
         [Fact]
         public void Synopsis_section_keeps_added_newlines()
         {
-            var command = new RootCommand(
+            var command = new CliRootCommand(
                 $"test{NewLine}\r\ndescription with\nline breaks");
 
             _helpBuilder.Write(command, _console);
@@ -62,7 +62,7 @@ public void Synopsis_section_properly_wraps_description()
                 "description with some tabs that is long enough to wrap to a\t" +
                 "new line";
 
-            var command = new RootCommand(description: longSynopsisText);
+            var command = new CliRootCommand(description: longSynopsisText);
 
             HelpBuilder helpBuilder = GetHelpBuilder(SmallMaxWidth);
             helpBuilder.Write(command, _console);
@@ -77,7 +77,7 @@ public void Synopsis_section_properly_wraps_description()
         [Fact]
         public void Command_name_in_synopsis_can_be_specified()
         {
-            var command = new Command("custom-name");
+            var command = new CliCommand("custom-name");
 
             var helpBuilder = GetHelpBuilder(SmallMaxWidth);
             helpBuilder.Write(command, _console);
@@ -101,19 +101,19 @@ public void Command_name_in_synopsis_can_be_specified()
             int maxArity,
             string expectedArgsUsage)
         {
-            var argument = new Argument<string>("the-args")
+            var argument = new CliArgument<string>("the-args")
             {
                 Arity = new ArgumentArity(minArity, maxArity)
             };
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
                 argument,
-                new Option<string>("--verbosity", "-v")
+                new CliOption<string>("--verbosity", "-v")
                 {
                     Description = "Sets the verbosity"
                 }
             };
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.Subcommands.Add(command);
 
             new HelpBuilder(LargeMaxWidth).Write(command, _console);
@@ -136,26 +136,26 @@ public void Command_name_in_synopsis_can_be_specified()
             int maxArityForArg2,
             string expectedArgsUsage)
         {
-            var arg1 = new Argument<string>("arg1")
+            var arg1 = new CliArgument<string>("arg1")
             {
                 Arity = new ArgumentArity(
                     minArityForArg1,
                     maxArityForArg1)
             };
-            var arg2 = new Argument<string>("arg2")
+            var arg2 = new CliArgument<string>("arg2")
             {
                 Arity = new ArgumentArity(
                     minArityForArg2,
                     maxArityForArg2)
             };
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
                 arg1,
                 arg2,
-                new Option<string>("--verbosity", "-v") { Description = "Sets the verbosity" }
+                new CliOption<string>("--verbosity", "-v") { Description = "Sets the verbosity" }
             };
 
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.Subcommands.Add(command);
 
             _helpBuilder.Write(command, _console);
@@ -170,13 +170,13 @@ public void Command_name_in_synopsis_can_be_specified()
         [Fact]
         public void Usage_section_for_subcommand_shows_names_of_parent_commands()
         {
-            var outer = new Command("outer", "the outer command");
-            var inner = new Command("inner", "the inner command");
+            var outer = new CliCommand("outer", "the outer command");
+            var inner = new CliCommand("inner", "the inner command");
             outer.Subcommands.Add(inner);
-            var innerEr = new Command("inner-er", "the inner-er command");
+            var innerEr = new CliCommand("inner-er", "the inner-er command");
             inner.Subcommands.Add(innerEr);
-            innerEr.Options.Add(new Option<string>("--some-option") { Description = "some option" });
-            var rootCommand = new RootCommand();
+            innerEr.Options.Add(new CliOption<string>("--some-option") { Description = "some option" });
+            var rootCommand = new CliRootCommand();
             rootCommand.Add(outer);
 
             _helpBuilder.Write(innerEr, _console);
@@ -191,15 +191,15 @@ public void Usage_section_for_subcommand_shows_names_of_parent_commands()
         [Fact]
         public void Usage_section_for_subcommand_shows_arguments_for_subcommand_and_parent_command()
         {
-            var inner = new Command("inner", "command help")
+            var inner = new CliCommand("inner", "command help")
             {
-                new Option<string>("-v") {Description = "Sets the verbosity" },
-                new Argument<string[]>("inner-args")
+                new CliOption<string>("-v") {Description = "Sets the verbosity" },
+                new CliArgument<string[]>("inner-args")
             };
-            _ = new Command("outer", "command help")
+            _ = new CliCommand("outer", "command help")
             {
                 inner,
-                new Argument<string[]>("outer-args")
+                new CliArgument<string[]>("outer-args")
             };
 
             _helpBuilder.Write(inner, _console);
@@ -214,11 +214,11 @@ public void Usage_section_for_subcommand_shows_arguments_for_subcommand_and_pare
         [Fact]
         public void Usage_section_does_not_show_additional_arguments_when_TreatUnmatchedTokensAsErrors_is_not_specified()
         {
-            var command = new Command(
+            var command = new CliCommand(
                 "some-command",
                 "Does something");
             command.Options.Add(
-                new Option<string>("-x") { Description = "Indicates whether x" });
+                new CliOption<string>("-x") { Description = "Indicates whether x" });
 
             _helpBuilder.Write(command, _console);
 
@@ -228,10 +228,10 @@ public void Usage_section_does_not_show_additional_arguments_when_TreatUnmatched
         [Fact]
         public void Usage_section_does_not_show_additional_arguments_when_TreatUnmatchedTokensAsErrors_is_true()
         {
-            var command = new RootCommand();
-            var subcommand = new Command("some-command", "Does something");
+            var command = new CliRootCommand();
+            var subcommand = new CliCommand("some-command", "Does something");
             command.Subcommands.Add(subcommand);
-            subcommand.Options.Add(new Option<string>("-x") { Description = "Indicates whether x" });
+            subcommand.Options.Add(new CliOption<string>("-x") { Description = "Indicates whether x" });
             subcommand.TreatUnmatchedTokensAsErrors = true;
 
             _helpBuilder.Write(subcommand, _console);
@@ -242,10 +242,10 @@ public void Usage_section_does_not_show_additional_arguments_when_TreatUnmatched
         [Fact]
         public void Usage_section_shows_additional_arguments_when_TreatUnmatchedTokensAsErrors_is_false()
         {
-            var command = new RootCommand();
-            var subcommand = new Command("some-command", "Does something");
+            var command = new CliRootCommand();
+            var subcommand = new CliCommand("some-command", "Does something");
             command.Subcommands.Add(subcommand);
-            subcommand.Options.Add(new Option<string>("-x") { Description = "Indicates whether x" });
+            subcommand.Options.Add(new CliOption<string>("-x") { Description = "Indicates whether x" });
             subcommand.TreatUnmatchedTokensAsErrors = false;
 
             _helpBuilder.Write(subcommand, _console);
@@ -256,12 +256,12 @@ public void Usage_section_shows_additional_arguments_when_TreatUnmatchedTokensAs
         [Fact]
         public void Usage_section_keeps_added_newlines()
         {
-            var outer = new Command("outer-command", "command help")
+            var outer = new CliCommand("outer-command", "command help")
             {
-                new Argument<string[]>($"outer args {NewLine}\r\nwith new\nlines"),
-                new Command("inner-command", "command help")
+                new CliArgument<string[]>($"outer args {NewLine}\r\nwith new\nlines"),
+                new CliCommand("inner-command", "command help")
                 {
-                    new Argument<string>("inner-args")
+                    new CliArgument<string>("inner-args")
                 }
             };
 
@@ -282,18 +282,18 @@ public void Usage_section_properly_wraps_description()
         {
             var helpBuilder = GetHelpBuilder(SmallMaxWidth);
 
-            var outerCommand = new Command("outer-command", "command help")
+            var outerCommand = new CliCommand("outer-command", "command help")
             {
-                new Argument<string[]>("outer args long enough to wrap to a new line"),
-                new Command("inner-command", "command help")
+                new CliArgument<string[]>("outer args long enough to wrap to a new line"),
+                new CliCommand("inner-command", "command help")
                 {
-                    new Argument<string[]>("inner-args")
+                    new CliArgument<string[]>("inner-args")
                 }
             };
             //NB: Using Command with a fixed name, rather than RootCommand here
             //because RootCommand.ExecutableName returns different values when
             //run under net5 vs net462
-            _ = new Command("System.CommandLine")
+            _ = new CliCommand("System.CommandLine")
             {
                 outerCommand
             };
@@ -313,14 +313,14 @@ public void Usage_section_does_not_contain_hidden_argument()
         {
             var commandName = "the-command";
             var visibleArgName = "visible";
-            var command = new Command(commandName, "Does things");
-            var hiddenArg = new Argument<int>("hidden")
+            var command = new CliCommand(commandName, "Does things");
+            var hiddenArg = new CliArgument<int>("hidden")
             {
-                IsHidden = true
+                Hidden = true
             };
-            var visibleArg = new Argument<int>(visibleArgName)
+            var visibleArg = new CliArgument<int>(visibleArgName)
             {
-                IsHidden = false
+                Hidden = false
             };
             command.Arguments.Add(hiddenArg);
             command.Arguments.Add(visibleArg);
@@ -343,7 +343,7 @@ public void Usage_section_does_not_contain_hidden_argument()
         [Fact]
         public void Arguments_section_is_not_included_if_there_are_no_commands_configured()
         {
-            _helpBuilder.Write(new RootCommand(), _console);
+            _helpBuilder.Write(new CliRootCommand(), _console);
 
             _console.ToString().Should().NotContain("Arguments:");
         }
@@ -351,7 +351,7 @@ public void Arguments_section_is_not_included_if_there_are_no_commands_configure
         [Fact]
         public void Arguments_section_is_not_included_if_there_are_commands_but_no_arguments_configured()
         {
-            var command = new Command("the-command", "command help");
+            var command = new CliCommand("the-command", "command help");
 
             _helpBuilder.Write(command, _console);
             _console.ToString().Should().NotContain("Arguments:");
@@ -363,9 +363,9 @@ public void Arguments_section_is_not_included_if_there_are_commands_but_no_argum
         [Fact]
         public void Arguments_section_is_included_if_there_are_commands_with_arguments_configured()
         {
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
-                new Argument<string>("arg command name")
+                new CliArgument<string>("arg command name")
                 {
                     Description = "test"
                 }
@@ -379,9 +379,9 @@ public void Arguments_section_is_included_if_there_are_commands_with_arguments_c
         [Fact]
         public void Arguments_section_is_not_included_if_there_are_options_with_no_arguments_configured()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("--verbosity", "-v") { Description = "Sets the verbosity." }
+                new CliOption<string>("--verbosity", "-v") { Description = "Sets the verbosity." }
             };
 
             _helpBuilder.Write(command, _console);
@@ -392,9 +392,9 @@ public void Arguments_section_is_not_included_if_there_are_options_with_no_argum
         [Fact]
         public void Arguments_section_is_not_included_if_there_are_only_options_with_arguments_configured()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Option<string>("-v")
+                new CliOption<string>("-v")
                 {
                     Description = "Sets the verbosity.",
                     HelpName = "argument for options"
@@ -409,9 +409,9 @@ public void Arguments_section_is_not_included_if_there_are_only_options_with_arg
         [Fact]
         public void Arguments_section_includes_configured_argument_aliases()
         {
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
-                new Option<string>("--verbosity", "-v")
+                new CliOption<string>("--verbosity", "-v")
                 {
                     HelpName = "LEVEL",
                     Description = "Sets the verbosity."
@@ -436,9 +436,9 @@ private enum VerbosityOptions
         [Fact]
         public void Arguments_section_uses_name_over_suggestions_if_specified()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<VerbosityOptions>("--verbosity", "-v")
+                new CliOption<VerbosityOptions>("--verbosity", "-v")
                 {
                     HelpName = "LEVEL"
                 }
@@ -453,9 +453,9 @@ public void Arguments_section_uses_name_over_suggestions_if_specified()
         [Fact]
         public void Arguments_section_uses_description_if_provided()
         {
-            var command = new Command("the-command", "Help text from description")
+            var command = new CliCommand("the-command", "Help text from description")
             {
-                new Argument<string>("the-arg")
+                new CliArgument<string>("the-arg")
                 {
                     Description = "Help text from HelpDetail"
                 }
@@ -473,20 +473,20 @@ public void Arguments_section_uses_description_if_provided()
         [Fact]
         public void Arguments_section_does_not_contain_hidden_argument()
         {
-            var command = new Command("the-command");
+            var command = new CliCommand("the-command");
             var hiddenArgName = "the-hidden";
             var hiddenDesc = "the hidden desc";
             var visibleArgName = "the-visible";
             var visibleDesc = "the visible desc";
-            var hiddenArg = new Argument<int>(hiddenArgName)
+            var hiddenArg = new CliArgument<int>(hiddenArgName)
             {
                 Description = hiddenDesc,
-                IsHidden = true
+                Hidden = true
             };
-            var visibleArg = new Argument<int>(visibleArgName)
+            var visibleArg = new CliArgument<int>(visibleArgName)
             {
                 Description = visibleDesc,
-                IsHidden = false
+                Hidden = false
             };
             command.Arguments.Add(hiddenArg);
             command.Arguments.Add(visibleArg);
@@ -506,15 +506,15 @@ public void Arguments_section_does_not_contain_hidden_argument()
         [Fact]
         public void Arguments_section_does_not_repeat_arguments_that_appear_on_parent_command()
         {
-            var reused = new Argument<string>("reused")
+            var reused = new CliArgument<string>("reused")
             {
                 Description = "This argument is valid on both outer and inner commands"
             };
-            var inner = new Command("inner", "The inner command")
+            var inner = new CliCommand("inner", "The inner command")
             {
                 reused
             };
-            _ = new Command("outer")
+            _ = new CliCommand("outer")
             {
                 reused,
                 inner
@@ -531,16 +531,16 @@ public void Arguments_section_does_not_repeat_arguments_that_appear_on_parent_co
         [Fact]
         public void Arguments_section_aligns_arguments_on_new_lines()
         {
-            var inner = new Command("inner", "HelpDetail text for the inner command")
+            var inner = new CliCommand("inner", "HelpDetail text for the inner command")
             {
-                new Argument<string>("the-inner-command-arg")
+                new CliArgument<string>("the-inner-command-arg")
                 {
                     Description = "The argument for the inner command",
                 }
             };
-            _ = new Command("outer", "HelpDetail text for the outer command")
+            _ = new CliCommand("outer", "HelpDetail text for the outer command")
             {
-                new Argument<string>("outer-command-arg")
+                new CliArgument<string>("outer-command-arg")
                 {
                     Description = "The argument for the outer command"
                 },
@@ -560,9 +560,9 @@ public void Arguments_section_aligns_arguments_on_new_lines()
         [Fact]
         public void Arguments_section_keeps_added_newlines()
         {
-            var command = new Command("outer", "Help text for the outer command")
+            var command = new CliCommand("outer", "Help text for the outer command")
             {
-                new Argument<string>("outer-command-arg")
+                new CliArgument<string>("outer-command-arg")
                 {
                     Description = $"The argument\r\nfor the\ninner command"
                 }
@@ -582,9 +582,9 @@ public void Arguments_section_keeps_added_newlines()
         [Fact]
         public void Arguments_section_keeps_added_newlines_when_width_is_very_small()
         {
-            var command = new Command("outer", "Help text for the outer command")
+            var command = new CliCommand("outer", "Help text for the outer command")
             {
-                new Argument<string>("outer-command-arg")
+                new CliArgument<string>("outer-command-arg")
                 {
                     Description = $"The argument\r\nfor the\ninner command",
                 }
@@ -613,9 +613,9 @@ public void Arguments_section_properly_wraps_description()
                 $"for inner command with some tabs that is long enough to wrap to a\t" +
                 $"new line";
 
-            var command = new Command("outer", "Help text for the outer command")
+            var command = new CliCommand("outer", "Help text for the outer command")
             {
-                new Argument<string>("outer-command-arg")
+                new CliArgument<string>("outer-command-arg")
                 {
                     Description = longCmdText
                 }
@@ -639,9 +639,9 @@ public void Arguments_section_properly_wraps()
             var name = "argument-name-for-a-command-that-is-long-enough-to-wrap-to-a-new-line";
             var description = "Argument description for a command with line breaks that is long enough to wrap to a new line.";
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Argument<string>(name)
+                new CliArgument<string>(name)
                 {
                     Description = description
                 }
@@ -667,12 +667,12 @@ public void Command_argument_usage_indicates_enums_values(bool nullable)
         {
             var description = "This is the argument description";
 
-            Argument argument = nullable
-                               ? new Argument<FileAccess?>("arg")
-                               : new Argument<FileAccess>("arg");
+            CliArgument argument = nullable
+                               ? new CliArgument<FileAccess?>("arg")
+                               : new CliArgument<FileAccess>("arg");
             argument.Description = description;
 
-            var command = new Command("outer", "Help text for the outer command")
+            var command = new CliCommand("outer", "Help text for the outer command")
             {
                 argument
             };
@@ -695,11 +695,11 @@ public void Option_argument_usage_is_empty_for_boolean_values(bool nullable)
         {
             var description = "This is the option description";
 
-            Option option = nullable
-                                ? new Option<bool?>("--opt") { Description = description }
-                                : new Option<bool>("--opt") { Description = description };
+            CliOption option = nullable
+                                ? new CliOption<bool?>("--opt") { Description = description }
+                                : new CliOption<bool>("--opt") { Description = description };
 
-            var command = new Command(
+            var command = new CliCommand(
                 "outer", "Help text for the outer command")
             {
                 option
@@ -715,10 +715,10 @@ public void Option_argument_usage_is_empty_for_boolean_values(bool nullable)
         [Fact] // https://github.com/dotnet/command-line-api/issues/1157
         public void Command_arguments_show_argument_name_in_first_column()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Argument<bool>("boolArgument") { Description = "Some value" },
-                new Argument<int>("intArgument") { Description = "Another value" },
+                new CliArgument<bool>("boolArgument") { Description = "Some value" },
+                new CliArgument<int>("intArgument") { Description = "Another value" },
             };
             
             var helpBuilder = GetHelpBuilder(SmallMaxWidth);
@@ -740,11 +740,11 @@ public void Option_argument_first_column_indicates_enums_values(bool nullable)
         {
             var description = "This is the argument description";
 
-            Option option = nullable
-                                ? new Option<FileAccess?>("--opt") { Description = description }
-                                : new Option<FileAccess>("--opt") { Description = description };
+            CliOption option = nullable
+                                ? new CliOption<FileAccess?>("--opt") { Description = description }
+                                : new CliOption<FileAccess>("--opt") { Description = description };
 
-            var command = new Command(
+            var command = new CliCommand(
                 "outer", "Help text for the outer command")
             {
                 option
@@ -760,13 +760,13 @@ public void Option_argument_first_column_indicates_enums_values(bool nullable)
         [Fact]
         public void Help_describes_default_value_for_argument()
         {
-            var argument = new Argument<string>("the-arg")
+            var argument = new CliArgument<string>("the-arg")
             {
                 Description = "Help text from HelpDetail",
                 DefaultValueFactory = (_) => "the-arg-value"
             };
 
-            var command = new Command("the-command",
+            var command = new CliCommand("the-command",
                 "Help text from description") { argument };
 
             HelpBuilder helpBuilder = GetHelpBuilder(SmallMaxWidth);
@@ -781,13 +781,13 @@ public void Help_describes_default_value_for_argument()
         [Fact]
         public void Help_does_not_show_default_value_for_argument_when_default_value_is_empty()
         {
-            var argument = new Argument<string>("the-arg")
+            var argument = new CliArgument<string>("the-arg")
             { 
                 Description = "The argument description",
                 DefaultValueFactory = (_) => ""
             };
             
-            var command = new Command("the-command", "The command description")
+            var command = new CliCommand("the-command", "The command description")
             {
                 argument
             };
@@ -804,13 +804,13 @@ public void Help_does_not_show_default_value_for_argument_when_default_value_is_
         [Fact]
         public void Help_does_not_show_default_value_for_option_when_default_value_is_empty()
         {
-            var option = new Option<string>("-x")
+            var option = new CliOption<string>("-x")
             {
                 Description = "The option description",
                 DefaultValueFactory = (_) => "",
             };
 
-            var command = new Command("the-command", "The command description")
+            var command = new CliCommand("the-command", "The command description")
             {
                 option
             };
@@ -827,15 +827,15 @@ public void Help_does_not_show_default_value_for_option_when_default_value_is_em
         [Fact]
         public void Command_arguments_default_value_provided()
         {
-            var argument = new Argument<string>("the-arg")
+            var argument = new CliArgument<string>("the-arg")
             {
                 DefaultValueFactory = (_) => "the-arg-value",
             };
-            var otherArgument = new Argument<string>("the-other-arg")
+            var otherArgument = new CliArgument<string>("the-other-arg")
             {
                 DefaultValueFactory = (_) => "the-other-arg-value"
             };
-            var command = new Command("the-command",
+            var command = new CliCommand("the-command",
                 "Help text from description")
             {
                 argument,
@@ -859,9 +859,9 @@ public void Command_arguments_default_value_provided()
         [Fact]
         public void Command_arguments_with_default_values_that_are_enumerable_display_pipe_delimited_list()
         {
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
-                new Argument<List<int>>("filter-size")
+                new CliArgument<List<int>>("filter-size")
                 {
                     DefaultValueFactory = (_) => new List<int>() { 0, 2, 4 }
                 }   
@@ -878,21 +878,21 @@ public void Command_arguments_with_default_values_that_are_enumerable_display_pi
         [Fact]
         public void Command_shared_arguments_with_one_or_more_arity_are_displayed_as_being_required()
         {
-            var arg = new Argument<string[]>("shared-args")
+            var arg = new CliArgument<string[]>("shared-args")
             {
                 Arity = ArgumentArity.OneOrMore
             };
 
-            var inner = new Command("inner", "command help")
+            var inner = new CliCommand("inner", "command help")
             {
                 arg
             };
-            _ = new Command("outer", "command help")
+            _ = new CliCommand("outer", "command help")
             {
                 inner,
                 arg
             };
-            _ = new Command("unused", "command help")
+            _ = new CliCommand("unused", "command help")
             {
                 arg
             };
@@ -913,9 +913,9 @@ public void Command_shared_arguments_with_one_or_more_arity_are_displayed_as_bei
         [Fact]
         public void Options_section_is_not_included_if_no_options_configured()
         {
-            var commandLineBuilder = new Command("noOptions")
+            var commandLineBuilder = new CliCommand("noOptions")
             {
-                new Command("outer", "description for outer")
+                new CliCommand("outer", "description for outer")
             };
 
             _helpBuilder.Write(commandLineBuilder, _console);
@@ -926,8 +926,8 @@ public void Options_section_is_not_included_if_no_options_configured()
         [Fact]
         public void Options_section_is_not_included_if_only_subcommands_configured()
         {
-            var command = new Command("outer", "description for outer");
-            command.Subcommands.Add(new Command("inner"));
+            var command = new CliCommand("outer", "description for outer");
+            command.Subcommands.Add(new CliCommand("inner"));
 
             _helpBuilder.Write(command, _console);
 
@@ -937,10 +937,10 @@ public void Options_section_is_not_included_if_only_subcommands_configured()
         [Fact]
         public void Options_section_includes_option_with_empty_description()
         {
-            var command = new Command("the-command", "Does things.")
+            var command = new CliCommand("the-command", "Does things.")
                           {
-                              new Option<string>("-x"),
-                              new Option<string>("-n"),
+                              new CliOption<string>("-x"),
+                              new CliOption<string>("-n"),
                               new HelpOption()
                           };
 
@@ -954,16 +954,16 @@ public void Options_section_includes_option_with_empty_description()
         [Fact]
         public void Options_section_does_not_contain_option_with_HelpDefinition_that_IsHidden()
         {
-            var command = new Command("the-command");
-            command.Options.Add(new Option<string>("-x")
+            var command = new CliCommand("the-command");
+            command.Options.Add(new CliOption<string>("-x")
             {
                 Description = "Is Hidden",
-                IsHidden = true
+                Hidden = true
             });
-            command.Options.Add(new Option<string>("-n")
+            command.Options.Add(new CliOption<string>("-n")
             {
                 Description = "Not Hidden",
-                IsHidden = false
+                Hidden = false
             });
 
 
@@ -979,13 +979,13 @@ public void Options_section_does_not_contain_option_with_HelpDefinition_that_IsH
         [Fact]
         public void Options_section_aligns_options_on_new_lines()
         {
-            var command = new Command("the-command", "Help text for the command")
+            var command = new CliCommand("the-command", "Help text for the command")
             {
-                new Option<string>("--aaa", "-a")
+                new CliOption<string>("--aaa", "-a")
                 {
                     Description = "An option with 8 characters",
                 },
-                new Option<string>("--bbbbbbbbbb","-b")
+                new CliOption<string>("--bbbbbbbbbb","-b")
                 {
                     Description = "An option with 15 characters"
                 }
@@ -1007,9 +1007,9 @@ public void Options_section_aligns_options_on_new_lines()
         [Fact]
         public void Retains_single_dash_on_multi_char_option()
         {
-            var command = new Command("command", "Help Test")
+            var command = new CliCommand("command", "Help Test")
             {
-                new Option<string>("-multi", "--alt-option") { Description = "HelpDetail for option" }
+                new CliOption<string>("-multi", "--alt-option") { Description = "HelpDetail for option" }
             };
 
             _helpBuilder.Write(command, _console);
@@ -1022,9 +1022,9 @@ public void Retains_single_dash_on_multi_char_option()
         [Fact]
         public void Options_section_retains_multiple_dashes_on_single_char_option()
         {
-            var command = new Command("command", "Help Test")
+            var command = new CliCommand("command", "Help Test")
             {
-                new Option<string>("--m", "--alt-option") { Description = "HelpDetail for option" }
+                new CliOption<string>("--m", "--alt-option") { Description = "HelpDetail for option" }
             };
 
             _helpBuilder.Write(command, _console);
@@ -1036,11 +1036,11 @@ public void Options_section_retains_multiple_dashes_on_single_char_option()
         public void Options_section_keeps_added_newlines()
         {
             var command =
-                new Command(
+                new CliCommand(
                     "test-command",
                     "Help text for the command")
                 {
-                    new Option<bool>("--aaa", "-a")
+                    new CliOption<bool>("--aaa", "-a")
                     {
                         Description = $"Help{NewLine}for \r\n the\noption"
                     }
@@ -1064,11 +1064,11 @@ public void Options_section_properly_wraps_description()
             var longOptionText =
                 "The option whose description is long enough that it wraps to a new line";
 
-            var command = new Command("test-command", "Help text for the command")
+            var command = new CliCommand("test-command", "Help text for the command")
             {
-                new Option<string>("-x") { Description = "Option with a short description" },
-                new Option<bool>("--aaa", "-a") { Description = longOptionText },
-                new Option<string>("-y") { Description = "Option with a short description" },
+                new CliOption<string>("-x") { Description = "Option with a short description" },
+                new CliOption<bool>("--aaa", "-a") { Description = longOptionText },
+                new CliOption<string>("-y") { Description = "Option with a short description" },
             };
 
             HelpBuilder helpBuilder = GetHelpBuilder(SmallMaxWidth);
@@ -1089,15 +1089,15 @@ public void Options_section_properly_wraps_description_when_long_default_value_i
             var longOptionText =
                 "The option whose description is long enough that it wraps to a new line";
 
-            var command = new Command("test-command", "Help text for the command")
+            var command = new CliCommand("test-command", "Help text for the command")
             {
-                new Option<string>("-x") { Description = "Option with a short description" },
-                new Option<string>("--aaa", "-a")
+                new CliOption<string>("-x") { Description = "Option with a short description" },
+                new CliOption<string>("--aaa", "-a")
                 {
                     Description = longOptionText,
                     DefaultValueFactory = (_) => "the quick brown fox jumps over the lazy dog"
                 },
-                new Option<string>("-y") { Description = "Option with a short description" },
+                new CliOption<string>("-y") { Description = "Option with a short description" },
             };
 
             HelpBuilder helpBuilder = GetHelpBuilder(SmallMaxWidth);
@@ -1117,9 +1117,9 @@ public void Options_section_properly_wraps()
             var alias = "--option-alias-for-a-command-that-is-long-enough-to-wrap-to-a-new-line";
             var description = "Option description that is long enough to wrap.";
 
-            var command = new Command("test")
+            var command = new CliCommand("test")
             {
-                new Option<bool>(alias) { Description = description }
+                new CliOption<bool>(alias) { Description = description }
             };
 
             HelpBuilder helpBuilder = GetHelpBuilder(SmallMaxWidth);
@@ -1137,11 +1137,11 @@ public void Options_section_properly_wraps()
         [Fact]
         public void Required_options_are_indicated()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<bool>("--required")
+                new CliOption<bool>("--required")
                 {
-                    IsRequired = true
+                    Required = true
                 }
             };
 
@@ -1156,11 +1156,11 @@ public void Required_options_are_indicated()
         [Fact]
         public void Required_options_are_indicated_when_argument_is_named()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("--required", "-r")
+                new CliOption<string>("--required", "-r")
                 {
-                    IsRequired = true,
+                    Required = true,
                     HelpName = "ARG"
                 }
             };
@@ -1176,7 +1176,7 @@ public void Required_options_are_indicated_when_argument_is_named()
         [Fact]
         public void Help_option_is_shown_in_help()
         {
-            var configuration = new CommandLineConfiguration(new RootCommand());
+            var configuration = new CommandLineConfiguration(new CliRootCommand());
 
             _helpBuilder.Write(configuration.RootCommand, _console);
 
@@ -1190,9 +1190,9 @@ public void Help_option_is_shown_in_help()
         [Fact]
         public void Options_aliases_differing_only_by_prefix_are_deduplicated_favoring_dashed_prefixes()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("-x", "/x")
+                new CliOption<string>("-x", "/x")
             };
 
             _helpBuilder.Write(command, _console);
@@ -1205,9 +1205,9 @@ public void Options_aliases_differing_only_by_prefix_are_deduplicated_favoring_d
         [Fact]
         public void Options_aliases_differing_only_by_prefix_are_deduplicated_favoring_double_dashed_prefixes()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("--long", "/long")
+                new CliOption<string>("--long", "/long")
             };
 
             _helpBuilder.Write(command, _console);
@@ -1220,12 +1220,12 @@ public void Options_aliases_differing_only_by_prefix_are_deduplicated_favoring_d
         [Fact]
         public void Options_help_preserves_the_order_options_are_added_the_the_parent_command()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<bool>("--first", "-f"),
-                new Option<bool>("--second", "-s"),
-                new Option<bool>("--third"),
-                new Option<bool>("--last", "-l")
+                new CliOption<bool>("--first", "-f"),
+                new CliOption<bool>("--second", "-s"),
+                new CliOption<bool>("--third"),
+                new CliOption<bool>("--last", "-l")
             };
 
             _helpBuilder.Write(command, _console);
@@ -1244,9 +1244,9 @@ public void Options_help_preserves_the_order_options_are_added_the_the_parent_co
         [Fact]
         public void Option_aliases_are_shown_before_long_names_regardless_of_alphabetical_order()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("-z", "-a", "--zzz", "--aaa")
+                new CliOption<string>("-z", "-a", "--zzz", "--aaa")
             };
 
             _helpBuilder.Write(command, _console);
@@ -1257,9 +1257,9 @@ public void Option_aliases_are_shown_before_long_names_regardless_of_alphabetica
         [Fact]
         public void Help_describes_default_value_for_option_with_argument_having_default_value()
         {
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
-                new Option<string>("-arg")
+                new CliOption<string>("-arg")
                 {
                     DefaultValueFactory = (_) => "the-arg-value",
                     HelpName = "the-arg"
@@ -1278,9 +1278,9 @@ public void Help_describes_default_value_for_option_with_argument_having_default
         [Fact]
         public void Option_arguments_with_default_values_that_are_enumerable_display_pipe_delimited_list()
         {
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
-                new Option<List<int>>("--filter-size")
+                new CliOption<List<int>>("--filter-size")
                 {
                     DefaultValueFactory = (_) => new List<int> { 0, 2, 4 }
                 }
@@ -1297,9 +1297,9 @@ public void Option_arguments_with_default_values_that_are_enumerable_display_pip
         [Fact]
         public void Option_arguments_with_default_values_that_are_array_display_pipe_delimited_list()
         {
-            var command = new Command("the-command", "command help")
+            var command = new CliCommand("the-command", "command help")
             {
-                new Option<string[]>("--prefixes")
+                new CliOption<string[]>("--prefixes")
                 {
                     DefaultValueFactory = (_) => new[]{ "^(TODO|BUG)", "^HACK" }
                 }
@@ -1322,17 +1322,17 @@ public void Option_arguments_with_default_values_that_are_array_display_pipe_del
         [Fact]
         public void Subcommand_help_does_not_include_names_of_sibling_commands()
         {
-            var inner = new Command("inner", "inner description")
+            var inner = new CliCommand("inner", "inner description")
             {
-                new Command("inner-er", "inner-er description")
+                new CliCommand("inner-er", "inner-er description")
                 {
-                    new Option<string>("some-option") { Description = "some-option description" }
+                    new CliOption<string>("some-option") { Description = "some-option description" }
                 }
             };
 
-            var sibling = new Command("sibling", "sibling description");
+            var sibling = new CliCommand("sibling", "sibling description");
 
-            var outer = new Command("outer", "outer description")
+            var outer = new CliCommand("outer", "outer description")
             {
                 sibling,
                 inner
@@ -1346,12 +1346,12 @@ public void Subcommand_help_does_not_include_names_of_sibling_commands()
         [Fact]
         public void Subcommands_keep_added_newlines()
         {
-            var command = new Command("outer", "outer command help")
+            var command = new CliCommand("outer", "outer command help")
             {
-                new Argument<string>("outer-args"),
-                new Command("inner", $"inner{NewLine}command help \r\n with \nnewlines")
+                new CliArgument<string>("outer-args"),
+                new CliCommand("inner", $"inner{NewLine}command help \r\n with \nnewlines")
                 {
-                    new Argument<string>("inner-args")
+                    new CliArgument<string>("inner-args")
                 }
             };
 
@@ -1377,13 +1377,13 @@ public void Subcommands_properly_wraps_description()
 
             var helpBuilder = GetHelpBuilder(SmallMaxWidth);
 
-            var command = new Command("outer-command", "outer command help")
+            var command = new CliCommand("outer-command", "outer command help")
             {
-                new Argument<string[]>("outer-args"),
-                new Command("inner-command", longSubcommandDescription)
+                new CliArgument<string[]>("outer-args"),
+                new CliCommand("inner-command", longSubcommandDescription)
                 {
-                    new Argument<string[]>("inner-args"),
-                    new Option<string>("--verbosity", "-v")
+                    new CliArgument<string[]>("inner-args"),
+                    new CliOption<string>("--verbosity", "-v")
                 }
             };
 
@@ -1403,9 +1403,9 @@ public void Subcommands_section_properly_wraps()
             var name = "subcommand-name-that-is-long-enough-to-wrap-to-a-new-line";
             var description = "Subcommand description that is really long. So long that it caused the line to wrap.";
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Command(name, description)
+                new CliCommand(name, description)
             };
 
             var helpBuilder = GetHelpBuilder(SmallMaxWidth);
@@ -1423,8 +1423,8 @@ public void Subcommands_section_properly_wraps()
         [Fact]
         public void Subcommand_help_contains_command_with_empty_description()
         {
-            var command = new Command("the-command", "Does things.");
-            var subCommand = new Command("the-subcommand", description: null);
+            var command = new CliCommand("the-command", "Does things.");
+            var subCommand = new CliCommand("the-subcommand", description: null);
             command.Subcommands.Add(subCommand);
 
             _helpBuilder.Write(command, _console);
@@ -1436,14 +1436,14 @@ public void Subcommand_help_contains_command_with_empty_description()
         [Fact]
         public void Subcommand_help_does_not_contain_hidden_command()
         {
-            var command = new Command("the-command", "Does things.");
-            var hiddenSubCommand = new Command("the-hidden")
+            var command = new CliCommand("the-command", "Does things.");
+            var hiddenSubCommand = new CliCommand("the-hidden")
             {
-                IsHidden = true
+                Hidden = true
             };
-            var visibleSubCommand = new Command("the-visible")
+            var visibleSubCommand = new CliCommand("the-visible")
             {
-                IsHidden = false
+                Hidden = false
             };
             command.Subcommands.Add(hiddenSubCommand);
             command.Subcommands.Add(visibleSubCommand);
@@ -1458,15 +1458,15 @@ public void Subcommand_help_does_not_contain_hidden_command()
         [Fact]
         public void Subcommand_help_does_not_contain_hidden_argument()
         {
-            var command = new Command("the-command", "Does things.");
-            var subCommand = new Command("the-subcommand");
-            var hidden = new Argument<int>("the-hidden")
+            var command = new CliCommand("the-command", "Does things.");
+            var subCommand = new CliCommand("the-subcommand");
+            var hidden = new CliArgument<int>("the-hidden")
             {
-                IsHidden = true
+                Hidden = true
             };
-            var visible = new Argument<int>("the-visible")
+            var visible = new CliArgument<int>("the-visible")
             {
-                IsHidden = false
+                Hidden = false
             };
             subCommand.Arguments.Add(hidden);
             subCommand.Arguments.Add(visible);
@@ -1486,22 +1486,22 @@ public void Subcommand_help_does_not_contain_hidden_argument()
         [Fact]
         public void Help_describes_default_value_for_subcommand_with_arguments_and_only_defaultable_is_shown()
         {
-            var argument = new Argument<string>("the-arg");
-            var otherArgumentHidden = new Argument<string>("the-other-hidden-arg")
+            var argument = new CliArgument<string>("the-arg");
+            var otherArgumentHidden = new CliArgument<string>("the-other-hidden-arg")
             {
-                IsHidden = true
+                Hidden = true
             };
             argument.DefaultValueFactory = _  => "the-arg-value";
             otherArgumentHidden.DefaultValueFactory = _ => "the-other-hidden-arg-value";
 
-            var command = new Command("outer", "outer command help")
+            var command = new CliCommand("outer", "outer command help")
                 {
-                    new Argument<string>("outer-args"),
-                    new Command("inner", $"inner command help")
+                    new CliArgument<string>("outer-args"),
+                    new CliCommand("inner", $"inner command help")
                     {
                         argument,
                         otherArgumentHidden,
-                        new Argument<string>("inner-other-arg-no-default")
+                        new CliArgument<string>("inner-other-arg-no-default")
                     }
                 };
 
@@ -1517,19 +1517,19 @@ public void Help_describes_default_value_for_subcommand_with_arguments_and_only_
         [Fact]
         public void Help_describes_default_values_for_subcommand_with_multiple_defaultable_arguments()
         {
-            var argument = new Argument<string>("the-arg")
+            var argument = new CliArgument<string>("the-arg")
             {
                 DefaultValueFactory = (_) => "the-arg-value"
             };
-            var otherArgument = new Argument<string>("the-other-arg")
+            var otherArgument = new CliArgument<string>("the-other-arg")
             {
                 DefaultValueFactory = (_) => "the-other-arg-value"
             };
 
-            var command = new Command("outer", "outer command help")
+            var command = new CliCommand("outer", "outer command help")
                 {
-                    new Argument<string>("outer-args"),
-                    new Command("inner", "inner command help")
+                    new CliArgument<string>("outer-args"),
+                    new CliCommand("inner", "inner command help")
                     {
                         argument, otherArgument
                     }
@@ -1557,9 +1557,9 @@ public void Constructor_ignores_non_positive_max_width(int maxWidth)
         [Fact] // https://github.com/dotnet/command-line-api/issues/1506
         public void Commands_without_arguments_do_not_produce_extra_newlines_between_usage_and_options_sections()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("-x") { Description = "the-option-description" }
+                new CliOption<string>("-x") { Description = "the-option-description" }
             };
 
             var helpBuilder = GetHelpBuilder();
diff --git a/src/System.CommandLine.Tests/HelpOptionTests.cs b/src/System.CommandLine.Tests/HelpOptionTests.cs
index a6f8109724..d40de71002 100644
--- a/src/System.CommandLine.Tests/HelpOptionTests.cs
+++ b/src/System.CommandLine.Tests/HelpOptionTests.cs
@@ -14,11 +14,11 @@ public class HelpOptionTests
         [Fact]
         public async Task Help_option_writes_help_for_the_specified_command()
         {
-            Command command = new RootCommand
+            CliCommand command = new CliRootCommand
             {
-                new Command("command")
+                new CliCommand("command")
                 {
-                    new Command("subcommand")
+                    new CliCommand("subcommand")
                 }
             };
 
@@ -31,15 +31,15 @@ public async Task Help_option_writes_help_for_the_specified_command()
 
             await result.InvokeAsync();
 
-            config.Output.ToString().Should().Contain($"{RootCommand.ExecutableName} command subcommand [options]");
+            config.Output.ToString().Should().Contain($"{CliRootCommand.ExecutableName} command subcommand [options]");
         }
          
         [Fact]
         public async Task Help_option_interrupts_execution_of_the_specified_command()
         {
             var wasCalled = false;
-            var command = new Command("command") { new HelpOption() };
-            var subcommand = new Command("subcommand");
+            var command = new CliCommand("command") { new HelpOption() };
+            var subcommand = new CliCommand("subcommand");
             subcommand.SetAction(_ => wasCalled = true);
             command.Subcommands.Add(subcommand);
 
@@ -60,7 +60,7 @@ public async Task Help_option_interrupts_execution_of_the_specified_command()
         [InlineData("/?")]
         public async Task Help_option_accepts_default_values(string value)
         {
-            CommandLineConfiguration config = new(new Command("command") { new HelpOption() })
+            CommandLineConfiguration config = new(new CliCommand("command") { new HelpOption() })
             {
                 Output = new StringWriter()
             };
@@ -76,8 +76,8 @@ public async Task Help_option_accepts_default_values(string value)
         [Fact]
         public async Task Help_option_does_not_display_when_option_defined_with_same_alias()
         {
-            var command = new Command("command");
-            command.Options.Add(new Option<bool>("-h"));
+            var command = new CliCommand("command");
+            command.Options.Add(new CliOption<bool>("-h"));
 
             CommandLineConfiguration config = new(command)
             {
@@ -92,7 +92,7 @@ public async Task Help_option_does_not_display_when_option_defined_with_same_ali
         [Fact]
         public void There_are_no_parse_errors_when_help_is_invoked_on_root_command()
         {
-            RootCommand rootCommand = new();
+            CliRootCommand rootCommand = new();
 
             var result = rootCommand.Parse("-h");
 
@@ -104,9 +104,9 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_root_command()
         [Fact]
         public void There_are_no_parse_errors_when_help_is_invoked_on_subcommand()
         {
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
-                new Command("subcommand"),
+                new CliCommand("subcommand"),
             };
 
             var result = root.Parse("subcommand -h");
@@ -119,9 +119,9 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_subcommand()
         [Fact]
         public void There_are_no_parse_errors_when_help_is_invoked_on_a_command_with_subcommands()
         {
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
-                new Command("subcommand"),
+                new CliCommand("subcommand"),
             };
 
             var result = root.Parse("-h");
@@ -132,11 +132,11 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_a_command_with_sub
         [Fact]
         public void There_are_no_parse_errors_when_help_is_invoked_on_a_command_with_required_options()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<string>("-x")
+                new CliOption<string>("-x")
                 {
-                    IsRequired = true
+                    Required = true
                 },
             };
 
@@ -150,7 +150,7 @@ public void There_are_no_parse_errors_when_help_is_invoked_on_a_command_with_req
         [InlineData("--confused")]
         public async Task HelpOption_with_custom_aliases_uses_aliases(string helpAlias)
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
                 new HelpOption("/lost", "--confused")
             };
@@ -172,7 +172,7 @@ public async Task HelpOption_with_custom_aliases_uses_aliases(string helpAlias)
         [InlineData("/?")]
         public async Task Help_option_with_custom_aliases_default_aliases_replaced(string helpAlias)
         {
-            RootCommand command = new();
+            CliRootCommand command = new();
             command.Options.Clear();
             command.Options.Add(new HelpOption("--confused"));
 
diff --git a/src/System.CommandLine.Tests/Invocation/CancelOnProcessTerminationTests.cs b/src/System.CommandLine.Tests/Invocation/CancelOnProcessTerminationTests.cs
index dcf22bb1dd..e468816582 100644
--- a/src/System.CommandLine.Tests/Invocation/CancelOnProcessTerminationTests.cs
+++ b/src/System.CommandLine.Tests/Invocation/CancelOnProcessTerminationTests.cs
@@ -19,7 +19,7 @@ public class CancelOnProcessTerminationTests
         private const int SIGTERM_EXIT_CODE = 143;
         private const int GracefulExitCode = 42;
 
-        private static readonly Option<bool> InfiniteDelayOption = new("--infiniteDelay");
+        private static readonly CliOption<bool> InfiniteDelayOption = new("--infiniteDelay");
 
         public enum Signals
         {
@@ -49,7 +49,7 @@ public async Task NonCancellableHandler_is_interrupted_on_process_termination()
 
         private static Task<int> Program(string[] args)
         {
-            RootCommand command = new ()
+            CliRootCommand command = new ()
             {
                 InfiniteDelayOption
             };
diff --git a/src/System.CommandLine.Tests/Invocation/InvocationTests.cs b/src/System.CommandLine.Tests/Invocation/InvocationTests.cs
index de15903fcb..70897eb2f1 100644
--- a/src/System.CommandLine.Tests/Invocation/InvocationTests.cs
+++ b/src/System.CommandLine.Tests/Invocation/InvocationTests.cs
@@ -15,7 +15,7 @@ public class InvocationTests
         [Fact]
         public async Task Command_InvokeAsync_enables_help_by_default()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 new HelpOption()
             };
@@ -38,7 +38,7 @@ public async Task Command_InvokeAsync_enables_help_by_default()
         [Fact]
         public void Command_Invoke_enables_help_by_default()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 new HelpOption()
             };
@@ -62,7 +62,7 @@ public void Command_Invoke_enables_help_by_default()
         public async Task RootCommand_InvokeAsync_returns_0_when_handler_is_successful()
         {
             var wasCalled = false;
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction((_) => wasCalled = true);
 
@@ -76,7 +76,7 @@ public async Task RootCommand_InvokeAsync_returns_0_when_handler_is_successful()
         public void RootCommand_Invoke_returns_0_when_handler_is_successful()
         {
             var wasCalled = false;
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction((_) => wasCalled = true);
 
@@ -90,7 +90,7 @@ public void RootCommand_Invoke_returns_0_when_handler_is_successful()
         public async Task RootCommand_InvokeAsync_returns_1_when_handler_throws()
         {
             var wasCalled = false;
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction((_, __) =>
             {
@@ -109,7 +109,7 @@ public async Task RootCommand_InvokeAsync_returns_1_when_handler_throws()
         public void RootCommand_Invoke_returns_1_when_handler_throws()
         {
             var wasCalled = false;
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction((_, __) =>
             {
@@ -131,7 +131,7 @@ public void RootCommand_Invoke_returns_1_when_handler_throws()
         [Fact]
         public void Custom_RootCommand_Action_can_set_custom_result_code_via_Invoke()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 Action = new CustomExitCodeAction()
             };
@@ -142,7 +142,7 @@ public void Custom_RootCommand_Action_can_set_custom_result_code_via_Invoke()
         [Fact]
         public async Task Custom_RootCommand_Action_can_set_custom_result_code_via_InvokeAsync()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 Action = new CustomExitCodeAction()
             };
@@ -153,7 +153,7 @@ public async Task Custom_RootCommand_Action_can_set_custom_result_code_via_Invok
         [Fact]
         public void Anonymous_RootCommand_Task_returning_Action_can_set_custom_result_code_via_Invoke()
         {
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction((_, _) => Task.FromResult(123));
 
@@ -163,7 +163,7 @@ public void Anonymous_RootCommand_Task_returning_Action_can_set_custom_result_co
         [Fact]
         public async Task Anonymous_RootCommand_Task_returning_Action_can_set_custom_result_code_via_InvokeAsync()
         {
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction((_, _) => Task.FromResult(123));
 
@@ -172,7 +172,7 @@ public async Task Anonymous_RootCommand_Task_returning_Action_can_set_custom_res
         [Fact]
         public void Anonymous_RootCommand_int_returning_Action_can_set_custom_result_code_via_Invoke()
         {
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction(_ => 123);
 
@@ -182,7 +182,7 @@ public void Anonymous_RootCommand_int_returning_Action_can_set_custom_result_cod
         [Fact]
         public async Task Anonymous_RootCommand_int_returning_Action_can_set_custom_result_code_via_InvokeAsync()
         {
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
             rootCommand.SetAction(_ => 123);
 
@@ -202,7 +202,7 @@ public override Task<int> InvokeAsync(ParseResult context, CancellationToken can
         public async Task Command_InvokeAsync_with_cancelation_token_invokes_command_handler()
         {
             using CancellationTokenSource cts = new();
-            var command = new Command("test");
+            var command = new CliCommand("test");
             command.SetAction((_, cancellationToken) =>
             {
                 cancellationToken.Should().Be(cts.Token);
diff --git a/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs b/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs
index fb18eb0e97..a76c4c515b 100644
--- a/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs
+++ b/src/System.CommandLine.Tests/Invocation/TypoCorrectionTests.cs
@@ -11,9 +11,9 @@ public class TypoCorrectionTests
         [Fact]
         public async Task When_option_is_mistyped_it_is_suggested()
         {
-            RootCommand rootCommand = new () 
+            CliRootCommand rootCommand = new () 
             {
-                new Option<string>("info")
+                new CliOption<string>("info")
             };
 
             CommandLineConfiguration config = new(rootCommand)
@@ -32,8 +32,8 @@ public async Task When_option_is_mistyped_it_is_suggested()
         [Fact]
         public async Task When_there_are_no_matches_then_nothing_is_suggested()
         {
-            var option = new Option<bool>("info");
-            RootCommand rootCommand = new() { option };
+            var option = new CliOption<bool>("info");
+            CliRootCommand rootCommand = new() { option };
 
             CommandLineConfiguration configuration = new(rootCommand)
             {
@@ -51,8 +51,8 @@ public async Task When_there_are_no_matches_then_nothing_is_suggested()
         [Fact]
         public async Task When_command_is_mistyped_it_is_suggested()
         {
-            var command = new Command("restore");
-            RootCommand rootCommand = new() { command };
+            var command = new CliCommand("restore");
+            CliRootCommand rootCommand = new() { command };
 
             CommandLineConfiguration configuration = new(rootCommand)
             {
@@ -70,11 +70,11 @@ public async Task When_command_is_mistyped_it_is_suggested()
         [Fact]
         public async Task When_there_are_multiple_matches_it_picks_the_best_matches()
         {
-            var fromCommand = new Command("from");
-            var seenCommand = new Command("seen");
-            var aOption = new Option<bool>("a");
-            var beenOption = new Option<bool>("been");
-            RootCommand rootCommand = new ()
+            var fromCommand = new CliCommand("from");
+            var seenCommand = new CliCommand("seen");
+            var aOption = new CliOption<bool>("a");
+            var beenOption = new CliOption<bool>("been");
+            CliRootCommand rootCommand = new ()
             {
                 fromCommand,
                 seenCommand,
@@ -97,10 +97,10 @@ public async Task When_there_are_multiple_matches_it_picks_the_best_matches()
         [Fact]
         public async Task Hidden_commands_are_not_suggested()
         {
-            var fromCommand = new Command("from");
-            var seenCommand = new Command("seen") { IsHidden = true };
-            var beenCommand = new Command("been");
-            RootCommand rootCommand = new RootCommand
+            var fromCommand = new CliCommand("from");
+            var seenCommand = new CliCommand("seen") { Hidden = true };
+            var beenCommand = new CliCommand("been");
+            CliRootCommand rootCommand = new CliRootCommand
             {
                 fromCommand,
                 seenCommand,
@@ -123,9 +123,9 @@ public async Task Hidden_commands_are_not_suggested()
         [Fact]
         public async Task Arguments_are_not_suggested()
         {
-            var argument = new Argument<string>("the-argument");
-            var command = new Command("been");
-            var rootCommand = new RootCommand
+            var argument = new CliArgument<string>("the-argument");
+            var command = new CliCommand("been");
+            var rootCommand = new CliRootCommand
             {
                 argument,
                 command
@@ -147,10 +147,10 @@ public async Task Arguments_are_not_suggested()
         [Fact]
         public async Task Hidden_options_are_not_suggested()
         {
-            var fromOption = new Option<string>("from");
-            var seenOption = new Option<string>("seen") { IsHidden = true };
-            var beenOption = new Option<string>("been");
-            var rootCommand = new RootCommand
+            var fromOption = new CliOption<string>("from");
+            var seenOption = new CliOption<string>("seen") { Hidden = true };
+            var beenOption = new CliOption<string>("been");
+            var rootCommand = new CliRootCommand
             {
                 fromOption,
                 seenOption,
@@ -172,10 +172,10 @@ public async Task Hidden_options_are_not_suggested()
         [Fact]
         public async Task Suggestions_favor_matches_with_prefix()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
-                new Option<string>("/call", "-call", "--call"),
-                new Option<string>("/email", "-email", "--email")
+                new CliOption<string>("/call", "-call", "--call"),
+                new CliOption<string>("/email", "-email", "--email")
             };
             CommandLineConfiguration config = new(rootCommand)
             {
diff --git a/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs b/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs
index f34475c3d3..30b6a1b341 100644
--- a/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs
+++ b/src/System.CommandLine.Tests/OptionTests.MultipleArgumentsPerToken.cs
@@ -26,13 +26,13 @@ public Allowed(ITestOutputHelper output)
                 [Fact]
                 public void When_option_is_not_respecified_but_limit_is_not_reached_then_the_following_token_is_used_as_value()
                 {
-                    var animalsOption = new Option<string[]>("-a", "--animals")
+                    var animalsOption = new CliOption<string[]>("-a", "--animals")
                     {
                         AllowMultipleArgumentsPerToken = true,
                     };
-                    var vegetablesOption = new Option<string>("-v", "--vegetables");
+                    var vegetablesOption = new CliOption<string>("-v", "--vegetables");
 
-                    var command = new RootCommand
+                    var command = new CliRootCommand
                     {
                         animalsOption,
                         vegetablesOption
@@ -63,13 +63,13 @@ public void When_option_is_not_respecified_but_limit_is_not_reached_then_the_fol
                 [Fact]
                 public void When_option_is_not_respecified_and_limit_is_reached_then_the_following_token_is_unmatched()
                 {
-                    var animalsOption = new Option<string>("-a", "--animals")
+                    var animalsOption = new CliOption<string>("-a", "--animals")
                     {
                         AllowMultipleArgumentsPerToken = true
                     };
-                    var vegetablesOption = new Option<string[]>("-v", "--vegetables");
+                    var vegetablesOption = new CliOption<string[]>("-v", "--vegetables");
 
-                    var command = new RootCommand
+                    var command = new CliRootCommand
                     {
                         animalsOption,
                         vegetablesOption
@@ -102,14 +102,14 @@ public void When_option_is_not_respecified_and_limit_is_reached_then_the_followi
                 [InlineData("--option 1 --option 2 xyz")]
                 public void When_max_arity_is_1_then_subsequent_option_args_overwrite_previous_ones(string commandLine)
                 {
-                    var option = new Option<string>("--option")
+                    var option = new CliOption<string>("--option")
                     {
                         AllowMultipleArgumentsPerToken = true
                     };
-                    var command = new Command("the-command")
+                    var command = new CliCommand("the-command")
                     {
                         option,
-                        new Argument<string>("arg")
+                        new CliArgument<string>("arg")
                     };
 
                     var result = command.Parse(commandLine);
@@ -122,12 +122,12 @@ public void When_max_arity_is_1_then_subsequent_option_args_overwrite_previous_o
                 [Fact]
                 public void All_consumed_tokens_are_present_in_option_result()
                 {
-                    var option = new Option<int>("-x")
+                    var option = new CliOption<int>("-x")
                     {
                         AllowMultipleArgumentsPerToken = true
                     };
 
-                    var result = new RootCommand { option }.Parse("-x 1 -x 2 -x 3 -x 4");
+                    var result = new CliRootCommand { option }.Parse("-x 1 -x 2 -x 3 -x 4");
 
                     _output.WriteLine(result.Diagram());
 
@@ -142,16 +142,16 @@ public void All_consumed_tokens_are_present_in_option_result()
                 [Fact]
                 public void Multiple_option_arguments_that_match_single_arity_option_aliases_are_parsed_correctly()
                 {
-                    var optionX = new Option<string>("-x")
+                    var optionX = new CliOption<string>("-x")
                     {
                         AllowMultipleArgumentsPerToken = true
                     };
-                    var optionY = new Option<string>("-y")
+                    var optionY = new CliOption<string>("-y")
                     {
                         AllowMultipleArgumentsPerToken = true
                     };
 
-                    var command = new RootCommand
+                    var command = new CliRootCommand
                     {
                         optionX,
                         optionY
@@ -172,8 +172,8 @@ public class Disallowed
                 [Fact]
                 public void Single_option_arg_is_matched()
                 {
-                    var option = new Option<string[]>("--option") { AllowMultipleArgumentsPerToken = false };
-                    var command = new Command("the-command") { option };
+                    var option = new CliOption<string[]>("--option") { AllowMultipleArgumentsPerToken = false };
+                    var command = new CliCommand("the-command") { option };
 
                     var result = command.Parse("--option 1 2");
 
@@ -185,8 +185,8 @@ public void Single_option_arg_is_matched()
                 [Fact]
                 public void Subsequent_matched_arguments_result_in_errors()
                 {
-                    var option = new Option<string[]>("--option") { AllowMultipleArgumentsPerToken = false };
-                    var command = new Command("the-command") { option };
+                    var option = new CliOption<string[]>("--option") { AllowMultipleArgumentsPerToken = false };
+                    var command = new CliCommand("the-command") { option };
 
                     var result = command.Parse("--option 1 2");
 
@@ -197,8 +197,8 @@ public void Subsequent_matched_arguments_result_in_errors()
                 [Fact]
                 public void When_max_arity_is_greater_than_1_then_multiple_option_args_are_matched()
                 {
-                    var option = new Option<string[]>("--option") { AllowMultipleArgumentsPerToken = false };
-                    var command = new Command("the-command") { option };
+                    var option = new CliOption<string[]>("--option") { AllowMultipleArgumentsPerToken = false };
+                    var command = new CliCommand("the-command") { option };
 
                     var result = command.Parse("--option 1 --option 2");
 
diff --git a/src/System.CommandLine.Tests/OptionTests.cs b/src/System.CommandLine.Tests/OptionTests.cs
index dcd4714a43..d0cc6f804c 100644
--- a/src/System.CommandLine.Tests/OptionTests.cs
+++ b/src/System.CommandLine.Tests/OptionTests.cs
@@ -14,7 +14,7 @@ public partial class OptionTests
         [Fact]
         public void When_an_option_has_only_name_then_it_has_no_aliases()
         {
-            var option = new Option<string>("myname");
+            var option = new CliOption<string>("myname");
 
             option.Name.Should().Be("myname");
             option.Aliases.Should().BeEmpty();
@@ -23,7 +23,7 @@ public void When_an_option_has_only_name_then_it_has_no_aliases()
         [Fact]
         public void When_an_option_has_several_aliases_then_they_do_not_affect_its_name()
         {
-            var option = new Option<string>(name: "m", aliases: new[] { "longer" });
+            var option = new CliOption<string>(name: "m", aliases: new[] { "longer" });
 
             option.Name.Should().Be("m");
         }
@@ -31,7 +31,7 @@ public void When_an_option_has_several_aliases_then_they_do_not_affect_its_name(
         [Fact]
         public void Option_names_can_contain_prefix_characters()
         {
-            var option = new Option<string>("--myname");
+            var option = new CliOption<string>("--myname");
 
             option.Name.Should().Be("--myname");
         }
@@ -39,7 +39,7 @@ public void Option_names_can_contain_prefix_characters()
         [Fact]
         public void Aliases_is_aware_of_added_alias()
         {
-            var option = new Option<string>("--original");
+            var option = new CliOption<string>("--original");
 
             option.Aliases.Add("--added");
 
@@ -49,7 +49,7 @@ public void Aliases_is_aware_of_added_alias()
         [Fact]
         public void RawAliases_is_aware_of_added_alias()
         {
-            var option = new Option<string>("--original");
+            var option = new CliOption<string>("--original");
 
             option.Aliases.Add("--added");
 
@@ -59,7 +59,7 @@ public void RawAliases_is_aware_of_added_alias()
         [Fact]
         public void A_prefixed_alias_can_be_added_to_an_option()
         {
-            var option = new Option<string>("--apple");
+            var option = new CliOption<string>("--apple");
 
             option.Aliases.Add("-a");
 
@@ -69,7 +69,7 @@ public void A_prefixed_alias_can_be_added_to_an_option()
         [Fact]
         public void Option_aliases_are_case_sensitive()
         {
-            var option = new Option<string>("name", "o");
+            var option = new CliOption<string>("name", "o");
 
             option.Aliases.Contains("O").Should().BeFalse();
         }
@@ -77,7 +77,7 @@ public void Option_aliases_are_case_sensitive()
         [Fact]
         public void Aliases_accepts_prefixed_short_value()
         {
-            var option = new Option<string>("--option", "-o");
+            var option = new CliOption<string>("--option", "-o");
 
             option.Aliases.Contains("-o").Should().BeTrue();
         }
@@ -85,7 +85,7 @@ public void Aliases_accepts_prefixed_short_value()
         [Fact]
         public void HasAlias_accepts_prefixed_long_value()
         {
-            var option = new Option<string>("-o", "--option");
+            var option = new CliOption<string>("-o", "--option");
 
             option.Aliases.Contains("--option").Should().BeTrue();
         }
@@ -93,7 +93,7 @@ public void HasAlias_accepts_prefixed_long_value()
         [Fact]
         public void It_is_not_necessary_to_specify_a_prefix_when_adding_an_option()
         {
-            var option = new Option<string>("o");
+            var option = new CliOption<string>("o");
 
             option.Name.Should().Be("o");
             option.Aliases.Should().BeEmpty();
@@ -102,7 +102,7 @@ public void It_is_not_necessary_to_specify_a_prefix_when_adding_an_option()
         [Fact]
         public void An_option_does_not_need_to_have_at_any_aliases()
         {
-            var option = new Option<string>("justName");
+            var option = new CliOption<string>("justName");
 
             option.Aliases.Should().BeEmpty();
         }
@@ -110,7 +110,7 @@ public void An_option_does_not_need_to_have_at_any_aliases()
         [Fact]
         public void An_option_cannot_have_an_empty_alias()
         {
-            Action create = () => new Option<string>("name", "");
+            Action create = () => new CliOption<string>("name", "");
 
             create.Should()
                   .Throw<ArgumentException>()
@@ -123,7 +123,7 @@ public void An_option_cannot_have_an_empty_alias()
         [Fact]
         public void An_option_cannot_have_an_alias_consisting_entirely_of_whitespace()
         {
-            Action create = () => new Option<string>("name", "  \t");
+            Action create = () => new CliOption<string>("name", "  \t");
 
             create.Should()
                   .Throw<ArgumentException>()
@@ -136,7 +136,7 @@ public void An_option_cannot_have_an_alias_consisting_entirely_of_whitespace()
         [Fact]
         public void Raw_aliases_are_exposed_by_an_option()
         {
-            var option = new Option<string>("--help", "-h", "/?");
+            var option = new CliOption<string>("--help", "-h", "/?");
 
             option.Aliases
                   .Should()
@@ -150,7 +150,7 @@ public void Raw_aliases_are_exposed_by_an_option()
         public void When_an_option_is_created_with_a_name_that_contains_whitespace_then_an_informative_error_is_returned(
             string name)
         {
-            Action create = () => new Option<string>(name);
+            Action create = () => new CliOption<string>(name);
 
             create.Should()
                   .Throw<ArgumentException>()
@@ -166,7 +166,7 @@ public void Raw_aliases_are_exposed_by_an_option()
         [InlineData("--aa aa")]
         public void When_an_option_alias_is_added_and_contains_whitespace_then_an_informative_error_is_returned(string alias)
         {
-            var option = new Option<bool>("-x");
+            var option = new CliOption<bool>("-x");
 
             Action addAlias = () => option.Aliases.Add(alias);
 
@@ -184,11 +184,11 @@ public void When_an_option_alias_is_added_and_contains_whitespace_then_an_inform
         [InlineData("/")]
         public void When_options_use_different_prefixes_they_still_work(string prefix)
         {
-            var optionA = new Option<string>(prefix + "a");
-            var optionB = new Option<string>(prefix + "b");
-            var optionC = new Option<string>(prefix + "c");
+            var optionA = new CliOption<string>(prefix + "a");
+            var optionB = new CliOption<string>(prefix + "b");
+            var optionC = new CliOption<string>(prefix + "c");
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
                               {
                                   optionA,
                                   optionB,
@@ -205,20 +205,20 @@ public void When_options_use_different_prefixes_they_still_work(string prefix)
         [Fact]
         public void When_option_not_explicitly_provides_help_will_use_default_help()
         {
-            var option = new Option<string>("--option", "-o")
+            var option = new CliOption<string>("--option", "-o")
             {
                 Description = "desc"
             };
 
             option.Name.Should().Be("--option");
             option.Description.Should().Be("desc");
-            option.IsHidden.Should().BeFalse();
+            option.Hidden.Should().BeFalse();
         }
         
         [Fact]
         public void Argument_retains_name_when_it_is_provided()
         {
-            var option = new Option<string>("-alias")
+            var option = new CliOption<string>("-alias")
             {
                 HelpName = "arg"
             };
@@ -229,12 +229,12 @@ public void Argument_retains_name_when_it_is_provided()
         [Fact]
         public void Option_T_default_value_can_be_set_via_the_constructor()
         {
-            var option = new Option<int>("-x")
+            var option = new CliOption<int>("-x")
             {
                 DefaultValueFactory = _ => 123
             };
 
-            new RootCommand { option }
+            new CliRootCommand { option }
                 .Parse("")
                 .FindResultFor(option)
                 .GetValueOrDefault<int>()
@@ -245,12 +245,12 @@ public void Option_T_default_value_can_be_set_via_the_constructor()
         [Fact]
         public void Option_T_default_value_can_be_set_after_instantiation()
         {
-            var option = new Option<int>("-x")
+            var option = new CliOption<int>("-x")
             {
                 DefaultValueFactory = (_) => 123
             };
 
-            new RootCommand { option }
+            new CliRootCommand { option }
                 .Parse("")
                 .FindResultFor(option)
                 .GetValueOrDefault<int>()
@@ -261,11 +261,11 @@ public void Option_T_default_value_can_be_set_after_instantiation()
         [Fact]
         public void Option_T_default_value_factory_can_be_set_after_instantiation()
         {
-            var option = new Option<int>("-x");
+            var option = new CliOption<int>("-x");
 
             option.DefaultValueFactory = (_) => 123;
 
-            new RootCommand { option }
+            new CliRootCommand { option }
                 .Parse("")
                 .FindResultFor(option)
                 .GetValueOrDefault<int>()
@@ -276,7 +276,7 @@ public void Option_T_default_value_factory_can_be_set_after_instantiation()
         [Fact]
         public void Option_T_default_value_is_validated()
         {
-            var option = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var option = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
             option.Validators.Add(symbol =>
                                     symbol.AddError(symbol.Tokens
                                                                 .Select(t => t.Value)
@@ -284,7 +284,7 @@ public void Option_T_default_value_is_validated()
                                                                 .Select(_ => "ERR")
                                                                 .First()));
 
-            new RootCommand { option }
+            new CliRootCommand { option }
                 .Parse("-x 123")
                 .Errors
                 .Select(e => e.Message)
@@ -295,9 +295,9 @@ public void Option_T_default_value_is_validated()
         [Fact]
         public void Option_of_string_defaults_to_null_when_not_specified()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
 
-            var result = new RootCommand { option }.Parse("");
+            var result = new CliRootCommand { option }.Parse("");
             result.FindResultFor(option)
                 .Should()
                 .BeNull();
@@ -311,9 +311,9 @@ public void Option_of_string_defaults_to_null_when_not_specified()
         [InlineData("-option:value")]
         public void When_aliases_overlap_the_longer_alias_is_chosen(string parseInput)
         {
-            var option = new Option<string>("-o", "-option");
+            var option = new CliOption<string>("-o", "-option");
 
-            var parseResult = new RootCommand { option }.Parse(parseInput);
+            var parseResult = new CliRootCommand { option }.Parse(parseInput);
 
             parseResult.GetValue(option).Should().Be("value");
         }
@@ -321,9 +321,9 @@ public void When_aliases_overlap_the_longer_alias_is_chosen(string parseInput)
         [Fact]
         public void Option_of_boolean_defaults_to_false_when_not_specified()
         {
-            var option = new Option<bool>("-x");
+            var option = new CliOption<bool>("-x");
 
-            var result = new RootCommand { option }.Parse("");
+            var result = new CliRootCommand { option }.Parse("");
 
             result.FindResultFor(option)
                 .Should()
@@ -336,10 +336,10 @@ public void Option_of_boolean_defaults_to_false_when_not_specified()
         [Fact]
         public void Option_of_enum_can_limit_enum_members_as_valid_values()
         {
-            Option<ConsoleColor> option = new("--color");
+            CliOption<ConsoleColor> option = new("--color");
             option.AcceptOnlyFromAmong(ConsoleColor.Red.ToString(), ConsoleColor.Green.ToString());
 
-            var result = new RootCommand { option }.Parse("--color Fuschia");
+            var result = new CliRootCommand { option }.Parse("--color Fuschia");
 
             result.Errors
                 .Select(e => e.Message)
@@ -353,11 +353,11 @@ public void Every_option_can_provide_a_handler_and_it_takes_precedence_over_comm
             OptionAction optionAction = new();
             bool commandHandlerWasCalled = false;
 
-            Option<bool> option = new("--test")
+            CliOption<bool> option = new("--test")
             {
                 Action = optionAction,
             };
-            Command command = new Command("cmd")
+            CliCommand command = new CliCommand("cmd")
             {
                 option
             };
@@ -398,11 +398,11 @@ public void When_multiple_options_with_handlers_are_parsed_only_the_last_one_is_
             OptionAction optionAction2 = new();
             OptionAction optionAction3 = new();
             
-            Command command = new Command("cmd")
+            CliCommand command = new CliCommand("cmd")
             {
-                new Option<bool>("--1") { Action = optionAction1 },
-                new Option<bool>("--2") { Action = optionAction2 },
-                new Option<bool>("--3") { Action = optionAction3 }
+                new CliOption<bool>("--1") { Action = optionAction1 },
+                new CliOption<bool>("--2") { Action = optionAction2 },
+                new CliOption<bool>("--3") { Action = optionAction3 }
             };
 
             ParseResult parseResult = command.Parse("cmd --1 true --3 false --2 true ");
diff --git a/src/System.CommandLine.Tests/ParseDiagramTests.cs b/src/System.CommandLine.Tests/ParseDiagramTests.cs
index 2f18b48c56..804ccaa317 100644
--- a/src/System.CommandLine.Tests/ParseDiagramTests.cs
+++ b/src/System.CommandLine.Tests/ParseDiagramTests.cs
@@ -13,13 +13,13 @@ public class ParseDiagramTests
         [Fact]
         public void Parse_result_diagram_helps_explain_parse_operation()
         {
-            Command command = 
-                new Command(
+            CliCommand command = 
+                new CliCommand(
                     "the-command")
                 {
-                    new Option<string>("-x"),
-                    new Option<bool>("-y"),
-                    new Argument<string[]>("arg")
+                    new CliOption<string>("-x"),
+                    new CliOption<bool>("-y"),
+                    new CliArgument<string[]>("arg")
                 };
 
             var result = command.Parse("the-command -x one -y two three");
@@ -32,10 +32,10 @@ public void Parse_result_diagram_helps_explain_parse_operation()
         [Fact]
         public void Parse_result_diagram_displays_unmatched_tokens()
         {
-            Option<string> option = new ("-x");
+            CliOption<string> option = new ("-x");
             option.AcceptOnlyFromAmong("arg1", "arg2", "arg3");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 option
             };
@@ -50,26 +50,26 @@ public void Parse_result_diagram_displays_unmatched_tokens()
         [Fact]
         public void Parse_diagram_shows_type_conversion_errors()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<int>("-f")
+                new CliOption<int>("-f")
             };
 
             var result = command.Parse("-f not-an-int");
 
             result.Diagram()
                   .Should()
-                  .Be($"[ {RootCommand.ExecutableName} ![ -f <not-an-int> ] ]");
+                  .Be($"[ {CliRootCommand.ExecutableName} ![ -f <not-an-int> ] ]");
         }
 
         [Fact]
         public void Parse_diagram_identifies_options_where_default_values_have_been_applied()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
-                new Option<int>("--height", "-h") { DefaultValueFactory = (_) => 10 },
-                new Option<int>("-w", "--width") { DefaultValueFactory = (_) => 15 },
-                new Option<ConsoleColor>("--color", "-c") { DefaultValueFactory = (_) => ConsoleColor.Cyan }
+                new CliOption<int>("--height", "-h") { DefaultValueFactory = (_) => 10 },
+                new CliOption<int>("-w", "--width") { DefaultValueFactory = (_) => 15 },
+                new CliOption<ConsoleColor>("--color", "-c") { DefaultValueFactory = (_) => ConsoleColor.Cyan }
             };
 
             var result = rootCommand.Parse("-w 9000");
@@ -77,17 +77,17 @@ public void Parse_diagram_identifies_options_where_default_values_have_been_appl
             var diagram = result.Diagram();
 
             diagram.Should()
-                   .Be($"[ {RootCommand.ExecutableName} [ -w <9000> ] *[ --height <10> ] *[ --color <Cyan> ] ]");
+                   .Be($"[ {CliRootCommand.ExecutableName} [ -w <9000> ] *[ --height <10> ] *[ --color <Cyan> ] ]");
         }
 
         [Fact]
         public void Parse_diagram_indicates_which_tokens_were_applied_to_which_command_argument()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<string>("first"),
-                new Argument<string> ("second"),
-                new Argument<string[]> ("third")
+                new CliArgument<string>("first"),
+                new CliArgument<string> ("second"),
+                new CliArgument<string[]> ("third")
             };
 
             var result = command.Parse("one two three four five");
@@ -100,11 +100,11 @@ public void Parse_diagram_indicates_which_tokens_were_applied_to_which_command_a
         [Fact]
         public void Parse_diagram_indicates_which_tokens_were_applied_to_which_command_argument_for_sequences_of_complex_types()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<FileInfo> ("first"),
-                new Argument<FileInfo> ("second"),
-                new Argument<FileInfo[]> ("third")
+                new CliArgument<FileInfo> ("first"),
+                new CliArgument<FileInfo> ("second"),
+                new CliArgument<FileInfo[]> ("third")
             };
 
             var result = command.Parse("one two three four five");
diff --git a/src/System.CommandLine.Tests/ParseDirectiveTests.cs b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
index f86e2fb478..997bfad512 100644
--- a/src/System.CommandLine.Tests/ParseDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
@@ -2,8 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using FluentAssertions;
-using System.CommandLine.Help;
-using System.CommandLine.Parsing;
 using System.IO;
 using System.Threading.Tasks;
 using Xunit;
@@ -23,16 +21,16 @@ public ParseDirectiveTests(ITestOutputHelper output)
         [Fact]
         public async Task Parse_directive_writes_parse_diagram()
         {
-            var rootCommand = new RootCommand();
-            var subcommand = new Command("subcommand");
+            var rootCommand = new CliRootCommand();
+            var subcommand = new CliCommand("subcommand");
             rootCommand.Subcommands.Add(subcommand);
-            var option = new Option<int>("-c", "--count");
+            var option = new CliOption<int>("-c", "--count");
             subcommand.Options.Add(option);
 
             CommandLineConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDirective() }
+                Directives = { new ParseDiagramDirective() }
             };
 
             var result = rootCommand.Parse("[parse] subcommand -c 34 --nonexistent wat", config);
@@ -44,18 +42,18 @@ public async Task Parse_directive_writes_parse_diagram()
             config.Output
                    .ToString()
                    .Should()
-                   .Be($"![ {RootCommand.ExecutableName} [ subcommand [ -c <34> ] ] ]   ???--> --nonexistent wat" + Environment.NewLine);
+                   .Be($"![ {CliRootCommand.ExecutableName} [ subcommand [ -c <34> ] ] ]   ???--> --nonexistent wat" + Environment.NewLine);
         }
 
         [Fact]
         public async Task When_parse_directive_is_used_the_help_is_not_displayed()
         {
-            RootCommand rootCommand = new ();
+            CliRootCommand rootCommand = new ();
 
             CommandLineConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDirective() }
+                Directives = { new ParseDiagramDirective() }
             };
 
             var result = rootCommand.Parse("[parse] --help", config);
@@ -67,18 +65,18 @@ public async Task When_parse_directive_is_used_the_help_is_not_displayed()
             config.Output
                    .ToString()
                    .Should()
-                   .Be($"[ {RootCommand.ExecutableName} [ --help ] ]" + Environment.NewLine);
+                   .Be($"[ {CliRootCommand.ExecutableName} [ --help ] ]" + Environment.NewLine);
         }
 
         [Fact]
         public async Task When_parse_directive_is_used_the_version_is_not_displayed()
         {
-            RootCommand rootCommand = new();
+            CliRootCommand rootCommand = new();
 
             CommandLineConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDirective() }
+                Directives = { new ParseDiagramDirective() }
             };
 
             var result = rootCommand.Parse("[parse] --version", config);
@@ -90,21 +88,21 @@ public async Task When_parse_directive_is_used_the_version_is_not_displayed()
             config.Output
                    .ToString()
                    .Should()
-                   .Be($"[ {RootCommand.ExecutableName} [ --version ] ]" + Environment.NewLine);
+                   .Be($"[ {CliRootCommand.ExecutableName} [ --version ] ]" + Environment.NewLine);
         }
 
         [Fact]
         public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0()
         {
-            RootCommand command = new ()
+            CliRootCommand command = new ()
             {
-                new Option<int>("-x")
+                new CliOption<int>("-x")
             };
 
             CommandLineConfiguration config = new(command)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDirective() }
+                Directives = { new ParseDiagramDirective() }
             };
 
             var exitCode = await command.Parse("[parse] -x 123", config).InvokeAsync();
@@ -115,15 +113,15 @@ public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0
         [Fact]
         public async Task When_there_are_errors_then_parse_directive_sets_exit_code_1()
         {
-            RootCommand command = new()
+            CliRootCommand command = new()
             {
-                new Option<int>("-x")
+                new CliOption<int>("-x")
             };
 
             CommandLineConfiguration config = new(command)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDirective() }
+                Directives = { new ParseDiagramDirective() }
             };
 
             var exitCode = await command.Parse("[parse] -x not-an-int", config).InvokeAsync();
@@ -134,15 +132,18 @@ public async Task When_there_are_errors_then_parse_directive_sets_exit_code_1()
         [Fact]
         public async Task When_there_are_errors_then_parse_directive_sets_exit_code_to_custom_value()
         {
-            RootCommand command = new ()
+            CliRootCommand command = new ()
             {
-                new Option<int>("-x")
+                new CliOption<int>("-x")
             };
 
             CommandLineConfiguration config = new(command)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDirective(errorExitCode: 42) }
+                Directives = { new ParseDiagramDirective
+                {
+                    ParseErrorReturnValue = 42
+                } }
             };
 
             int exitCode = await config.InvokeAsync("[parse] -x not-an-int");
diff --git a/src/System.CommandLine.Tests/ParseResultTests.cs b/src/System.CommandLine.Tests/ParseResultTests.cs
index fd48fe8f7e..341a630e84 100644
--- a/src/System.CommandLine.Tests/ParseResultTests.cs
+++ b/src/System.CommandLine.Tests/ParseResultTests.cs
@@ -13,9 +13,9 @@ public class ParseResultTests
         [Fact]
         public void An_option_with_a_default_value_and_no_explicitly_provided_argument_has_an_empty_arguments_property()
         {
-            var option = new Option<string>("-x") { DefaultValueFactory = (_) => "default" };
+            var option = new CliOption<string>("-x") { DefaultValueFactory = (_) => "default" };
 
-            var result = new RootCommand
+            var result = new CliRootCommand
             {
                 option
             }.Parse("-x")
@@ -27,9 +27,9 @@ public void An_option_with_a_default_value_and_no_explicitly_provided_argument_h
         [Fact]
         public void FindResult_can_be_used_to_check_the_presence_of_an_option()
         {
-            var option = new Option<bool>("-h", "--help");
+            var option = new CliOption<bool>("-h", "--help");
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -42,8 +42,8 @@ public void FindResult_can_be_used_to_check_the_presence_of_an_option()
         [Fact]
         public void FindResultFor_can_be_used_to_check_the_presence_of_an_implicit_option()
         {
-            var option = new Option<int>("-c", "--count") { DefaultValueFactory = (_) => 5 };
-            var command = new Command("the-command")
+            var option = new CliOption<int>("-c", "--count") { DefaultValueFactory = (_) => 5 };
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -56,18 +56,18 @@ public void FindResultFor_can_be_used_to_check_the_presence_of_an_implicit_optio
         [Fact]
         public void Command_will_not_accept_a_command_if_a_sibling_command_has_already_been_accepted()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
-                new Command("inner-one")
+                new CliCommand("inner-one")
                 {
-                    new Argument<bool>("arg1")
+                    new CliArgument<bool>("arg1")
                     {
                         Arity = ArgumentArity.Zero
                     }
                 },
-                new Command("inner-two")
+                new CliCommand("inner-two")
                 {
-                    new Argument<bool>("arg2")
+                    new CliArgument<bool>("arg2")
                     {
                         Arity = ArgumentArity.Zero
                     }
@@ -88,25 +88,25 @@ public void Command_will_not_accept_a_command_if_a_sibling_command_has_already_b
         [Fact] // https://github.com/dotnet/command-line-api/pull/2030#issuecomment-1400275332
         public void ParseResult_GetCompletions_returns_global_options_of_given_command_only()
         {
-            var leafCommand = new Command("leafCommand")
+            var leafCommand = new CliCommand("leafCommand")
             {
-                new Option<string>("--one") { Description = "option one" },
-                new Option<string>("--two") { Description = "option two" }
+                new CliOption<string>("--one") { Description = "option one" },
+                new CliOption<string>("--two") { Description = "option two" }
             };
 
-            var midCommand1 = new Command("midCommand1")
+            var midCommand1 = new CliCommand("midCommand1")
             {
                 leafCommand
             };
-            midCommand1.Options.Add(new Option<string>("--three1") { Description = "option three 1", AppliesToSelfAndChildren = true });
+            midCommand1.Options.Add(new CliOption<string>("--three1") { Description = "option three 1", Recursive = true });
 
-            var midCommand2 = new Command("midCommand2")
+            var midCommand2 = new CliCommand("midCommand2")
             {
                 leafCommand
             };
-            midCommand2.Options.Add(new Option<string>("--three2") { Description = "option three 2", AppliesToSelfAndChildren = true });
+            midCommand2.Options.Add(new CliOption<string>("--three2") { Description = "option three 2", Recursive = true });
 
-            var rootCommand = new Command("root")
+            var rootCommand = new CliCommand("root")
             {
                 midCommand1,
                 midCommand2
@@ -124,14 +124,14 @@ public void ParseResult_GetCompletions_returns_global_options_of_given_command_o
 
         [Fact]
         public void Handler_is_null_when_parsed_command_did_not_specify_handler()
-            => new RootCommand().Parse("").Action.Should().BeNull();
+            => new CliRootCommand().Parse("").Action.Should().BeNull();
 
         [Fact]
         public void Handler_is_not_null_when_parsed_command_specified_handler()
         {
             bool handlerWasCalled = false;
 
-            RootCommand command = new();
+            CliRootCommand command = new();
             command.SetAction((_) => handlerWasCalled = true);
 
             ParseResult parseResult = command.Parse("");
diff --git a/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs b/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs
index 930ebc6ffa..a31aec8935 100644
--- a/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs
+++ b/src/System.CommandLine.Tests/ParserTests.DoubleDash.cs
@@ -14,9 +14,9 @@ public class DefaultDoubleDashBehavior
             [Fact] // https://github.com/dotnet/command-line-api/issues/1238
             public void Subsequent_tokens_are_parsed_as_arguments_even_if_they_match_option_identifiers()
             {
-                var option = new Option<string[]>("-o", "--one");
-                var argument = new Argument<string[]>("arg");
-                var rootCommand = new RootCommand
+                var option = new CliOption<string[]>("-o", "--one");
+                var argument = new CliArgument<string[]>("arg");
+                var rootCommand = new CliRootCommand
                 {
                     option,
                     argument
@@ -36,9 +36,9 @@ public void Subsequent_tokens_are_parsed_as_arguments_even_if_they_match_option_
             [Fact]
             public void Unmatched_tokens_is_empty()
             {
-                var option = new Option<string[]>("-o", "--one");
-                var argument = new Argument<string[]>("arg");
-                var rootCommand = new RootCommand
+                var option = new CliOption<string[]>("-o", "--one");
+                var argument = new CliArgument<string[]>("arg");
+                var rootCommand = new CliRootCommand
                 {
                     option,
                     argument
@@ -52,9 +52,9 @@ public void Unmatched_tokens_is_empty()
             [Fact] // https://github.com/dotnet/command-line-api/issues/1631
             public void No_errors_are_generated()
             {
-                var option = new Option<string[]>("-o", "--one");
-                var argument = new Argument<string[]>("arg");
-                var rootCommand = new RootCommand
+                var option = new CliOption<string[]>("-o", "--one");
+                var argument = new CliArgument<string[]>("arg");
+                var rootCommand = new CliRootCommand
                 {
                     option,
                     argument
@@ -68,8 +68,8 @@ public void No_errors_are_generated()
             [Fact]
             public void A_second_double_dash_is_parsed_as_an_argument()
             {
-                var argument = new Argument<string[]>("arg");
-                var rootCommand = new RootCommand
+                var argument = new CliArgument<string[]>("arg");
+                var rootCommand = new CliRootCommand
                 {
                     argument
                 };
diff --git a/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs b/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs
index eb786d1951..9a08d16872 100644
--- a/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs
+++ b/src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs
@@ -18,17 +18,17 @@ public class MultipleArguments
             [Fact]
             public void Multiple_arguments_can_differ_by_arity()
             {
-                var multipleArityArg = new Argument<IEnumerable<string>>("several")
+                var multipleArityArg = new CliArgument<IEnumerable<string>>("several")
                 {
                     Arity = new ArgumentArity(3, 3),
                 };
 
-                var singleArityArg = new Argument<IEnumerable<string>>("one")
+                var singleArityArg = new CliArgument<IEnumerable<string>>("one")
                 {
                     Arity = ArgumentArity.ZeroOrMore,
                 };
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     multipleArityArg,
                     singleArityArg
@@ -47,10 +47,10 @@ public void Multiple_arguments_can_differ_by_arity()
             [Fact]
             public void Multiple_arguments_can_differ_by_type()
             {
-                var stringArg = new Argument<string>("the-string");
-                var intArg = new Argument<int>("the-int");
+                var stringArg = new CliArgument<string>("the-string");
+                var intArg = new CliArgument<int>("the-int");
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     stringArg,
                     intArg
@@ -77,12 +77,12 @@ public void Multiple_arguments_can_differ_by_type()
             [InlineData("one two three four five --verbose true")]
             public void When_multiple_arguments_are_present_then_their_order_relative_to_sibling_options_is_not_significant(string commandLine)
             {
-                var first = new Argument<string>("first");
-                var second = new Argument<string>("second");
-                var third = new Argument<string[]>("third");
-                var verbose = new Option<bool>("--verbose");
+                var first = new CliArgument<string>("first");
+                var second = new CliArgument<string>("second");
+                var third = new CliArgument<string[]>("third");
+                var verbose = new CliOption<bool>("--verbose");
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     first,
                     second,
@@ -116,9 +116,9 @@ public void When_multiple_arguments_are_present_then_their_order_relative_to_sib
             [Fact]
             public void Multiple_arguments_of_unspecified_type_are_parsed_correctly()
             {
-                var sourceArg = new Argument<string>("source");
-                var destinationArg = new Argument<string>("destination");
-                var root = new RootCommand
+                var sourceArg = new CliArgument<string>("source");
+                var destinationArg = new CliArgument<string>("destination");
+                var root = new CliRootCommand
                 {
                     sourceArg,
                     destinationArg
@@ -141,12 +141,12 @@ public void Multiple_arguments_of_unspecified_type_are_parsed_correctly()
             [Fact]
             public void When_multiple_arguments_are_defined_but_not_provided_then_option_parses_correctly()
             {
-                var option = new Option<string>("-e");
-                var command = new Command("the-command")
+                var option = new CliOption<string>("-e");
+                var command = new CliCommand("the-command")
                 {
                     option,
-                    new Argument<string>("arg1"),
-                    new Argument<string>("arg2")
+                    new CliArgument<string>("arg1"),
+                    new CliArgument<string>("arg2")
                 };
 
                 var result = command.Parse("-e foo");
@@ -159,10 +159,10 @@ public void When_multiple_arguments_are_defined_but_not_provided_then_option_par
             [Fact]
             public void Tokens_that_cannot_be_converted_by_multiple_arity_argument_flow_to_next_multiple_arity_argument()
             {
-                var ints = new Argument<int[]>("ints");
-                var strings = new Argument<string[]>("strings");
+                var ints = new CliArgument<int[]>("ints");
+                var strings = new CliArgument<string[]>("strings");
 
-                var root = new RootCommand
+                var root = new CliRootCommand
                 {
                     ints,
                     strings
@@ -186,10 +186,10 @@ public void Tokens_that_cannot_be_converted_by_multiple_arity_argument_flow_to_n
             [Fact]
             public void Tokens_that_cannot_be_converted_by_multiple_arity_argument_flow_to_next_single_arity_argument()
             {
-                var ints = new Argument<int[]>("arg1");
-                var strings = new Argument<string>("arg2");
+                var ints = new CliArgument<int[]>("arg1");
+                var strings = new CliArgument<string>("arg2");
 
-                var root = new RootCommand
+                var root = new CliRootCommand
                 {
                     ints,
                     strings
@@ -219,16 +219,16 @@ public void Tokens_that_cannot_be_converted_by_multiple_arity_argument_flow_to_n
             [Fact]
             public void Unsatisfied_subsequent_argument_with_min_arity_0_parses_as_default_value()
             {
-                var arg1 = new Argument<string>("arg1")
+                var arg1 = new CliArgument<string>("arg1")
                 {
                     Arity = ArgumentArity.ExactlyOne
                 };
-                var arg2 = new Argument<string>("arg2")
+                var arg2 = new CliArgument<string>("arg2")
                 {
                     Arity = ArgumentArity.ZeroOrOne,
                     DefaultValueFactory = (_) => "the-default"
                 };
-                var rootCommand = new RootCommand
+                var rootCommand = new CliRootCommand
                 {
                     arg1,
                     arg2,
@@ -243,13 +243,13 @@ public void Unsatisfied_subsequent_argument_with_min_arity_0_parses_as_default_v
             [Fact] // https://github.com/dotnet/command-line-api/issues/1403
             public void Unsatisfied_subsequent_argument_with_min_arity_1_parses_as_default_value()
             {
-                Argument<string> arg1 = new(name: "arg1");
-                Argument<string> arg2 = new(name: "arg2")
+                CliArgument<string> arg1 = new(name: "arg1");
+                CliArgument<string> arg2 = new(name: "arg2")
                 {
                     DefaultValueFactory = (_) => "the-default"
                 };
 
-                var rootCommand = new RootCommand
+                var rootCommand = new CliRootCommand
                 {
                     arg1,
                     arg2,
@@ -264,11 +264,11 @@ public void Unsatisfied_subsequent_argument_with_min_arity_1_parses_as_default_v
             [Fact] // https://github.com/dotnet/command-line-api/issues/1395
             public void When_subsequent_argument_with_ZeroOrOne_arity_is_not_provided_then_parse_is_correct()
             {
-                var argument1 = new Argument<string>("arg1");
-                var rootCommand = new RootCommand
+                var argument1 = new CliArgument<string>("arg1");
+                var rootCommand = new CliRootCommand
                 {
                     argument1,
-                    new Argument<string>("arg2")
+                    new CliArgument<string>("arg2")
                     {
                         Arity = ArgumentArity.ZeroOrOne
                     },
@@ -289,12 +289,12 @@ public void When_subsequent_argument_with_ZeroOrOne_arity_is_not_provided_then_p
             public void When_there_are_not_enough_tokens_for_all_arguments_then_the_correct_number_of_errors_is_reported(
                 string providedArgs)
             {
-                var command = new Command("command")
+                var command = new CliCommand("command")
                 {
-                    new Argument<string>("arg1"),
-                    new Argument<string>("arg2"),
-                    new Argument<string>("arg3"),
-                    new Argument<string>("arg4")
+                    new CliArgument<string>("arg1"),
+                    new CliArgument<string>("arg2"),
+                    new CliArgument<string>("arg3"),
+                    new CliArgument<string>("arg4")
                 };
 
                 var result = Parser.Parse(command, providedArgs);
diff --git a/src/System.CommandLine.Tests/ParserTests.MultiplePositions.cs b/src/System.CommandLine.Tests/ParserTests.MultiplePositions.cs
index 90e8c8dfd3..30bd45a8c1 100644
--- a/src/System.CommandLine.Tests/ParserTests.MultiplePositions.cs
+++ b/src/System.CommandLine.Tests/ParserTests.MultiplePositions.cs
@@ -17,11 +17,11 @@ public class MultiplePositions
             [InlineData("outer inner xyz")]
             public void An_argument_can_be_specified_in_more_than_one_position(string commandLine)
             {
-                var argument = new Argument<string>("the-argument");
+                var argument = new CliArgument<string>("the-argument");
 
-                var command = new Command("outer")
+                var command = new CliCommand("outer")
                 {
-                    new Command("inner")
+                    new CliCommand("inner")
                     {
                         argument
                     },
@@ -45,11 +45,11 @@ public void An_argument_can_be_specified_in_more_than_one_position(string comman
             [InlineData("outer inner xyz")]
             public void When_an_argument_is_shared_between_an_outer_and_inner_command_then_specifying_in_one_does_not_result_in_error_on_other(string commandLine)
             {
-                var argument = new Argument<string>("the-argument");
+                var argument = new CliArgument<string>("the-argument");
 
-                var command = new Command("outer")
+                var command = new CliCommand("outer")
                 {
-                    new Command("inner")
+                    new CliCommand("inner")
                     {
                         argument
                     },
@@ -66,11 +66,11 @@ public void When_an_argument_is_shared_between_an_outer_and_inner_command_then_s
             [InlineData("outer inner --the-option xyz")]
             public void An_option_can_be_specified_in_more_than_one_position(string commandLine)
             {
-                var option = new Option<string>("--the-option");
+                var option = new CliOption<string>("--the-option");
 
-                var command = new Command("outer")
+                var command = new CliCommand("outer")
                 {
-                    new Command("inner")
+                    new CliCommand("inner")
                     {
                         option
                     },
@@ -94,11 +94,11 @@ public void An_option_can_be_specified_in_more_than_one_position(string commandL
             [InlineData("outer inner --the-option xyz")]
             public void When_an_option_is_shared_between_an_outer_and_inner_command_then_specifying_in_one_does_not_result_in_error_on_other(string commandLine)
             {
-                var option = new Option<string>("--the-option");
+                var option = new CliOption<string>("--the-option");
 
-                var command = new Command("outer")
+                var command = new CliCommand("outer")
                 {
-                    new Command("inner")
+                    new CliCommand("inner")
                     {
                         option
                     },
@@ -117,17 +117,17 @@ public void When_an_option_is_shared_between_an_outer_and_inner_command_then_spe
                 string commandLine,
                 string expectedParent)
             {
-                var reusedCommand = new Command("reused");
+                var reusedCommand = new CliCommand("reused");
                 reusedCommand.SetAction((_) => { });
-                reusedCommand.Add(new Option<string>("--the-option"));
+                reusedCommand.Add(new CliOption<string>("--the-option"));
 
-                var outer = new Command("outer")
+                var outer = new CliCommand("outer")
                 {
-                    new Command("inner1")
+                    new CliCommand("inner1")
                     {
                         reusedCommand
                     },
-                    new Command("inner2")
+                    new CliCommand("inner2")
                     {
                         reusedCommand
                     }
@@ -150,25 +150,25 @@ public void When_an_option_is_shared_between_an_outer_and_inner_command_then_spe
             [Fact]
             public void An_option_can_have_multiple_parents_with_the_same_name()
             {
-                var option = new Option<string>("--the-option");
+                var option = new CliOption<string>("--the-option");
 
-                var sprocket = new Command("sprocket")
+                var sprocket = new CliCommand("sprocket")
                 {
-                    new Command("add")
+                    new CliCommand("add")
                     {
                         option
                     }
                 };
 
-                var widget = new Command("widget")
+                var widget = new CliCommand("widget")
                 {
-                    new Command("add")
+                    new CliCommand("add")
                     {
                         option
                     }
                 };
 
-                var root = new RootCommand
+                var root = new CliRootCommand
                 {
                     sprocket,
                     widget
diff --git a/src/System.CommandLine.Tests/ParserTests.RootCommandAndArg0.cs b/src/System.CommandLine.Tests/ParserTests.RootCommandAndArg0.cs
index 69aad02e74..d6f6816875 100644
--- a/src/System.CommandLine.Tests/ParserTests.RootCommandAndArg0.cs
+++ b/src/System.CommandLine.Tests/ParserTests.RootCommandAndArg0.cs
@@ -15,11 +15,11 @@ public partial class RootCommandAndArg0
         [Fact]
         public void When_parsing_a_string_array_a_root_command_can_be_omitted_from_the_parsed_args()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                 }
             };
 
@@ -32,31 +32,31 @@ public void When_parsing_a_string_array_a_root_command_can_be_omitted_from_the_p
         [Fact]
         public void When_parsing_a_string_array_input_then_a_full_path_to_an_executable_is_not_matched_by_the_root_command()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                 }
             };
 
             command.Parse(Split("inner -x hello")).Errors.Should().BeEmpty();
 
-            var parserResult = command.Parse(Split($"\"{RootCommand.ExecutablePath}\" inner -x hello"));
+            var parserResult = command.Parse(Split($"\"{CliRootCommand.ExecutablePath}\" inner -x hello"));
             parserResult
                .Errors
                .Should()
-               .ContainSingle(e => e.Message == LocalizationResources.UnrecognizedCommandOrArgument(RootCommand.ExecutablePath));
+               .ContainSingle(e => e.Message == LocalizationResources.UnrecognizedCommandOrArgument(CliRootCommand.ExecutablePath));
         }
 
         [Fact]
         public void When_parsing_an_unsplit_string_a_root_command_can_be_omitted_from_the_parsed_args()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                 }
             };
 
@@ -69,33 +69,33 @@ public void When_parsing_an_unsplit_string_a_root_command_can_be_omitted_from_th
         [Fact]
         public void When_parsing_an_unsplit_string_then_input_a_full_path_to_an_executable_is_matched_by_the_root_command()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                 }
             };
 
-            var result2 = command.Parse($"\"{RootCommand.ExecutablePath}\" inner -x hello");
+            var result2 = command.Parse($"\"{CliRootCommand.ExecutablePath}\" inner -x hello");
 
-            result2.RootCommandResult.IdentifierToken.Value.Should().Be(RootCommand.ExecutablePath);
+            result2.RootCommandResult.IdentifierToken.Value.Should().Be(CliRootCommand.ExecutablePath);
         }
 
         [Fact]
         public void When_parsing_an_unsplit_string_then_a_renamed_RootCommand_can_be_omitted_from_the_parsed_args()
         {
-            var rootCommand = new Command("outer")
+            var rootCommand = new CliCommand("outer")
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Option<string>("-x")
+                    new CliOption<string>("-x")
                 }
             };
 
             var result1 = rootCommand.Parse("inner -x hello");
             var result2 = rootCommand.Parse("outer inner -x hello");
-            var result3 = rootCommand.Parse($"{RootCommand.ExecutableName} inner -x hello");
+            var result3 = rootCommand.Parse($"{CliRootCommand.ExecutableName} inner -x hello");
 
             result2.RootCommandResult.Command.Should().BeSameAs(result1.RootCommandResult.Command);
             result3.RootCommandResult.Command.Should().BeSameAs(result1.RootCommandResult.Command);
diff --git a/src/System.CommandLine.Tests/ParserTests.cs b/src/System.CommandLine.Tests/ParserTests.cs
index 36b49d64de..74e1bdf7ad 100644
--- a/src/System.CommandLine.Tests/ParserTests.cs
+++ b/src/System.CommandLine.Tests/ParserTests.cs
@@ -23,18 +23,18 @@ public ParserTests(ITestOutputHelper output)
             _output = output;
         }
 
-        protected virtual T GetValue<T>(ParseResult parseResult, Option<T> option)
+        protected virtual T GetValue<T>(ParseResult parseResult, CliOption<T> option)
             => parseResult.GetValue(option);
 
-        protected virtual T GetValue<T>(ParseResult parseResult, Argument<T> argument)
+        protected virtual T GetValue<T>(ParseResult parseResult, CliArgument<T> argument)
             => parseResult.GetValue(argument);
 
         [Fact]
         public void An_option_can_be_checked_by_object_instance()
         {
-            var option = new Option<bool>("--flag");
-            var option2 = new Option<bool>("--flag2");
-            var result = new RootCommand { option, option2 }
+            var option = new CliOption<bool>("--flag");
+            var option2 = new CliOption<bool>("--flag2");
+            var result = new CliRootCommand { option, option2 }
                 .Parse("--flag");
 
             result.FindResultFor(option).Should().NotBeNull();
@@ -44,11 +44,11 @@ public void An_option_can_be_checked_by_object_instance()
         [Fact]
         public void Two_options_are_parsed_correctly()
         {
-            var optionOne = new Option<bool>("-o", "--one");
+            var optionOne = new CliOption<bool>("-o", "--one");
 
-            var optionTwo = new Option<bool>("-t", "--two");
+            var optionTwo = new CliOption<bool>("-t", "--two");
 
-            var result = new RootCommand { optionOne, optionTwo }.Parse("-o -t");
+            var result = new CliRootCommand { optionOne, optionTwo }.Parse("-o -t");
 
             result.FindResultFor(optionOne).Should().NotBeNull();
             result.FindResultFor(optionTwo).Should().NotBeNull();
@@ -59,7 +59,7 @@ public void Two_options_are_parsed_correctly()
         [InlineData("/")]
         public void When_a_token_is_just_a_prefix_then_an_error_is_returned(string prefix)
         {
-            var result = new RootCommand().Parse(prefix);
+            var result = new CliRootCommand().Parse(prefix);
 
             result.Errors
                   .Select(e => e.Message)
@@ -70,9 +70,9 @@ public void When_a_token_is_just_a_prefix_then_an_error_is_returned(string prefi
         [Fact]
         public void Short_form_options_can_be_specified_using_equals_delimiter()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
 
-            var result = new RootCommand { option }.Parse("-x=some-value");
+            var result = new CliRootCommand { option }.Parse("-x=some-value");
 
             result.Errors.Should().BeEmpty();
 
@@ -82,9 +82,9 @@ public void Short_form_options_can_be_specified_using_equals_delimiter()
         [Fact]
         public void Long_form_options_can_be_specified_using_equals_delimiter()
         {
-            var option = new Option<string>("--hello");
+            var option = new CliOption<string>("--hello");
 
-            var result = new RootCommand { option }.Parse("--hello=there");
+            var result = new CliRootCommand { option }.Parse("--hello=there");
 
             result.Errors.Should().BeEmpty();
 
@@ -94,9 +94,9 @@ public void Long_form_options_can_be_specified_using_equals_delimiter()
         [Fact]
         public void Short_form_options_can_be_specified_using_colon_delimiter()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
 
-            var result = new RootCommand { option }.Parse("-x:some-value");
+            var result = new CliRootCommand { option }.Parse("-x:some-value");
 
             result.Errors.Should().BeEmpty();
 
@@ -106,9 +106,9 @@ public void Short_form_options_can_be_specified_using_colon_delimiter()
         [Fact]
         public void Long_form_options_can_be_specified_using_colon_delimiter()
         {
-            var option = new Option<string>("--hello");
+            var option = new CliOption<string>("--hello");
 
-            var result = new RootCommand { option }.Parse("--hello:there");
+            var result = new CliRootCommand { option }.Parse("--hello:there");
 
             result.Errors.Should().BeEmpty();
 
@@ -118,10 +118,10 @@ public void Long_form_options_can_be_specified_using_colon_delimiter()
         [Fact]
         public void Option_short_forms_can_be_bundled()
         {
-            var command = new Command("the-command");
-            command.Options.Add(new Option<bool>("-x"));
-            command.Options.Add(new Option<bool>("-y"));
-            command.Options.Add(new Option<bool>("-z"));
+            var command = new CliCommand("the-command");
+            command.Options.Add(new CliOption<bool>("-x"));
+            command.Options.Add(new CliOption<bool>("-y"));
+            command.Options.Add(new CliOption<bool>("-z"));
 
             var result = command.Parse("the-command -xyz");
 
@@ -135,13 +135,13 @@ public void Option_short_forms_can_be_bundled()
         [Fact]
         public void Options_short_forms_do_not_get_unbundled_if_unbundling_is_turned_off()
         {
-            RootCommand rootCommand = new RootCommand()
+            CliRootCommand rootCommand = new CliRootCommand()
             {
-                new Command("the-command")
+                new CliCommand("the-command")
                 {
-                    new Option<bool>("-x"),
-                    new Option<bool>("-y"),
-                    new Option<bool>("-z")
+                    new CliOption<bool>("-x"),
+                    new CliOption<bool>("-y"),
+                    new CliOption<bool>("-z")
                 }
             };
 
@@ -160,13 +160,13 @@ public void Options_short_forms_do_not_get_unbundled_if_unbundling_is_turned_off
         [Fact]
         public void Option_long_forms_do_not_get_unbundled()
         {
-            Command command =
-                new Command("the-command")
+            CliCommand command =
+                new CliCommand("the-command")
                 {
-                    new Option<bool>("--xyz"),
-                    new Option<bool>("-x"),
-                    new Option<bool>("-y"),
-                    new Option<bool>("-z")
+                    new CliOption<bool>("--xyz"),
+                    new CliOption<bool>("-x"),
+                    new CliOption<bool>("-y"),
+                    new CliOption<bool>("-z")
                 };
 
             var result = command.Parse("the-command --xyz");
@@ -181,14 +181,14 @@ public void Option_long_forms_do_not_get_unbundled()
         [Fact]
         public void Options_do_not_get_unbundled_unless_all_resulting_options_would_be_valid_for_the_current_command()
         {
-            var outer = new Command("outer");
-            outer.Options.Add(new Option<bool>("-a"));
-            var inner = new Command("inner")
+            var outer = new CliCommand("outer");
+            outer.Options.Add(new CliOption<bool>("-a"));
+            var inner = new CliCommand("inner")
             {
-                new Argument<string[]>("arg")
+                new CliArgument<string[]>("arg")
             };
-            inner.Options.Add(new Option<bool>("-b"));
-            inner.Options.Add(new Option<bool>("-c"));
+            inner.Options.Add(new CliOption<bool>("-b"));
+            inner.Options.Add(new CliOption<bool>("-c"));
             outer.Subcommands.Add(inner);
 
             ParseResult result = outer.Parse("outer inner -abc");
@@ -203,11 +203,11 @@ public void Options_do_not_get_unbundled_unless_all_resulting_options_would_be_v
         [Fact]
         public void Required_option_arguments_are_not_unbundled()
         {
-            var optionA = new Option<string>("-a");
-            var optionB = new Option<bool>("-b");
-            var optionC = new Option<bool>("-c");
+            var optionA = new CliOption<string>("-a");
+            var optionB = new CliOption<bool>("-b");
+            var optionC = new CliOption<bool>("-c");
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionA,
                 optionB,
@@ -225,11 +225,11 @@ public void Required_option_arguments_are_not_unbundled()
         [Fact]
         public void Last_bundled_option_can_accept_argument_with_no_separator()
         {
-            var optionA = new Option<bool>("-a");
-            var optionB = new Option<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
-            var optionC = new Option<string>("-c") { Arity = ArgumentArity.ExactlyOne };
+            var optionA = new CliOption<bool>("-a");
+            var optionB = new CliOption<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
+            var optionC = new CliOption<string>("-c") { Arity = ArgumentArity.ExactlyOne };
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionA,
                 optionB,
@@ -249,11 +249,11 @@ public void Last_bundled_option_can_accept_argument_with_no_separator()
         [Fact]
         public void Last_bundled_option_can_accept_argument_with_equals_separator()
         {
-            var optionA = new Option<bool>("-a");
-            var optionB = new Option<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
-            var optionC = new Option<string>("-c") { Arity = ArgumentArity.ExactlyOne };
+            var optionA = new CliOption<bool>("-a");
+            var optionB = new CliOption<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
+            var optionC = new CliOption<string>("-c") { Arity = ArgumentArity.ExactlyOne };
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionA,
                 optionB,
@@ -273,11 +273,11 @@ public void Last_bundled_option_can_accept_argument_with_equals_separator()
         [Fact]
         public void Last_bundled_option_can_accept_argument_with_colon_separator()
         {
-            var optionA = new Option<bool>("-a");
-            var optionB = new Option<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
-            var optionC = new Option<string>("-c") { Arity = ArgumentArity.ExactlyOne };
+            var optionA = new CliOption<bool>("-a");
+            var optionB = new CliOption<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
+            var optionC = new CliOption<string>("-c") { Arity = ArgumentArity.ExactlyOne };
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionA,
                 optionB,
@@ -297,11 +297,11 @@ public void Last_bundled_option_can_accept_argument_with_colon_separator()
         [Fact]
         public void Invalid_char_in_bundle_causes_rest_to_be_interpreted_as_value()
         {
-            var optionA = new Option<bool>("-a");
-            var optionB = new Option<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
-            var optionC = new Option<string>("-c") { Arity = ArgumentArity.ExactlyOne };
+            var optionA = new CliOption<bool>("-a");
+            var optionB = new CliOption<string>("-b") { Arity = ArgumentArity.ZeroOrOne };
+            var optionC = new CliOption<string>("-c") { Arity = ArgumentArity.ExactlyOne };
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionA,
                 optionB,
@@ -323,9 +323,9 @@ public void Invalid_char_in_bundle_causes_rest_to_be_interpreted_as_value()
         [Fact]
         public void Parser_root_Options_can_be_specified_multiple_times_and_their_arguments_are_collated()
         {
-            var animalsOption = new Option<string[]>("-a", "--animals");
-            var vegetablesOption = new Option<string[]>("-v", "--vegetables");
-            var parser = new RootCommand
+            var animalsOption = new CliOption<string[]>("-a", "--animals");
+            var vegetablesOption = new CliOption<string[]>("-v", "--vegetables");
+            var parser = new CliRootCommand
             {
                 animalsOption,
                 vegetablesOption
@@ -349,11 +349,11 @@ public void Parser_root_Options_can_be_specified_multiple_times_and_their_argume
         [Fact]
         public void Options_can_be_specified_multiple_times_and_their_arguments_are_collated()
         {
-            var animalsOption = new Option<string[]>("-a", "--animals");
+            var animalsOption = new CliOption<string[]>("-a", "--animals");
             animalsOption.AcceptOnlyFromAmong("dog", "cat", "sheep");
-            var vegetablesOption = new Option<string[]>("-v", "--vegetables");
-            Command command =
-                new Command("the-command") {
+            var vegetablesOption = new CliOption<string[]>("-v", "--vegetables");
+            CliCommand command =
+                new CliCommand("the-command") {
                     animalsOption,
                     vegetablesOption
                 };
@@ -376,16 +376,16 @@ public void Options_can_be_specified_multiple_times_and_their_arguments_are_coll
         [Fact]
         public void When_an_option_is_not_respecified_but_limit_is_reached_then_the_following_token_is_considered_an_argument_to_the_parent_command()
         {
-            var animalsOption = new Option<string[]>("-a", "--animals");
+            var animalsOption = new CliOption<string[]>("-a", "--animals");
 
-            var vegetablesOption = new Option<string[]>("-v", "--vegetables");
+            var vegetablesOption = new CliOption<string[]>("-v", "--vegetables");
 
-            Command command = 
-                new Command("the-command")
+            CliCommand command = 
+                new CliCommand("the-command")
                 {
                     animalsOption,
                     vegetablesOption,
-                    new Argument<string[]>("arg")
+                    new CliArgument<string[]>("arg")
                 };
 
             var result = command.Parse("the-command -a cat some-arg -v carrot");
@@ -412,10 +412,10 @@ public void When_an_option_is_not_respecified_but_limit_is_reached_then_the_foll
         [Fact]
         public void Command_with_multiple_options_is_parsed_correctly()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
-                new Option<string>("--inner1"),
-                new Option<string>("--inner2")
+                new CliOption<string>("--inner1"),
+                new CliOption<string>("--inner2")
             };
 
             var result = command.Parse("outer --inner1 argument1 --inner2 argument2");
@@ -437,10 +437,10 @@ public void Command_with_multiple_options_is_parsed_correctly()
         [Fact]
         public void Relative_order_of_arguments_and_options_within_a_command_does_not_matter()
         {
-            var command = new Command("move")
+            var command = new CliCommand("move")
             {
-                new Argument<string[]>("arg"),
-                new Option<string>("-X")
+                new CliArgument<string[]>("arg"),
+                new CliOption<string>("-X")
             };
 
             // option before args
@@ -482,11 +482,11 @@ public void Original_order_of_tokens_is_preserved_in_ParseResult_Tokens(string c
         {
             var rawSplit = Parser.SplitCommandLine(commandLine);
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
                           {
-                              new Argument<string[]>("arg"),
-                              new Option<string>("--one"),
-                              new Option<string[]>("--many")
+                              new CliArgument<string[]>("arg"),
+                              new CliOption<string>("--one"),
+                              new CliOption<string[]>("--many")
                           };
 
             var result = command.Parse(commandLine);
@@ -497,13 +497,13 @@ public void Original_order_of_tokens_is_preserved_in_ParseResult_Tokens(string c
         [Fact]
         public void An_outer_command_with_the_same_name_does_not_capture()
         {
-            var command = new Command("one")
+            var command = new CliCommand("one")
                           {
-                              new Command("two")
+                              new CliCommand("two")
                               {
-                                  new Command("three")
+                                  new CliCommand("three")
                               },
-                              new Command("three")
+                              new CliCommand("three")
                           };
 
             ParseResult result = command.Parse("one two three");
@@ -514,13 +514,13 @@ public void An_outer_command_with_the_same_name_does_not_capture()
         [Fact]
         public void An_inner_command_with_the_same_name_does_not_capture()
         {
-            var command = new Command("one")
+            var command = new CliCommand("one")
                           {
-                              new Command("two")
+                              new CliCommand("two")
                               {
-                                  new Command("three")
+                                  new CliCommand("three")
                               },
-                              new Command("three")
+                              new CliCommand("three")
                           };
 
             ParseResult result = command.Parse("one three");
@@ -531,13 +531,13 @@ public void An_inner_command_with_the_same_name_does_not_capture()
         [Fact]
         public void When_nested_commands_all_accept_arguments_then_the_nearest_captures_the_arguments()
         {
-            var command = new Command(
+            var command = new CliCommand(
                 "outer")
             {
-                new Argument<string[]>("arg1"),
-                new Command("inner")
+                new CliArgument<string[]>("arg1"),
+                new CliCommand("inner")
                 {
-                    new Argument<string[]>("arg2")
+                    new CliArgument<string[]>("arg2")
                 }
             };
 
@@ -559,19 +559,19 @@ public void When_nested_commands_all_accept_arguments_then_the_nearest_captures_
         [Fact]
         public void Nested_commands_with_colliding_names_cannot_both_be_applied()
         {
-            var command = new Command("outer")
+            var command = new CliCommand("outer")
             {
-                new Argument<string>("arg1"),
-                new Command("non-unique")
+                new CliArgument<string>("arg1"),
+                new CliCommand("non-unique")
                 {
-                    new Argument<string>("arg2")
+                    new CliArgument<string>("arg2")
                 },
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Argument<string>("arg3"),
-                    new Command("non-unique")
+                    new CliArgument<string>("arg3"),
+                    new CliCommand("non-unique")
                     {
-                        new Argument<string>("arg4")
+                        new CliArgument<string>("arg4")
                     }
                 }
             };
@@ -584,11 +584,11 @@ public void Nested_commands_with_colliding_names_cannot_both_be_applied()
         [Fact]
         public void When_child_option_will_not_accept_arg_then_parent_can()
         {
-            var option = new Option<bool>("-x");
-            var command = new Command("the-command")
+            var option = new CliOption<bool>("-x");
+            var command = new CliCommand("the-command")
                          {
                              option,
-                             new Argument<string>("arg")
+                             new CliArgument<string>("arg")
                          };
 
             var result = command.Parse("the-command -x the-argument");
@@ -601,8 +601,8 @@ public void When_child_option_will_not_accept_arg_then_parent_can()
         [Fact]
         public void When_parent_option_will_not_accept_arg_then_child_can()
         {
-            var option = new Option<string>("-x");
-            var command = new Command("the-command")
+            var option = new CliOption<string>("-x");
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -616,11 +616,11 @@ public void When_parent_option_will_not_accept_arg_then_child_can()
         [Fact]
         public void Required_arguments_on_parent_commands_do_not_create_parse_errors_when_an_inner_command_is_specified()
         {
-            var child = new Command("child");
+            var child = new CliCommand("child");
 
-            var parent = new Command("parent")
+            var parent = new CliCommand("parent")
             {
-                new Argument<string>("arg"),
+                new CliArgument<string>("arg"),
                 child
             };
 
@@ -632,12 +632,12 @@ public void Required_arguments_on_parent_commands_do_not_create_parse_errors_whe
         [Fact]
         public void Required_arguments_on_grandparent_commands_do_not_create_parse_errors_when_an_inner_command_is_specified()
         {
-            var grandchild = new Command("grandchild");
+            var grandchild = new CliCommand("grandchild");
 
-            var grandparent = new Command("grandparent")
+            var grandparent = new CliCommand("grandparent")
             {
-                new Argument<string>("arg"),
-                new Command("parent")
+                new CliArgument<string>("arg"),
+                new CliCommand("parent")
                 {
                     grandchild
                 }
@@ -651,13 +651,13 @@ public void Required_arguments_on_grandparent_commands_do_not_create_parse_error
         [Fact]
         public void When_options_with_the_same_name_are_defined_on_parent_and_child_commands_and_specified_at_the_end_then_it_attaches_to_the_inner_command()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
                         {
-                            new Command("inner")
+                            new CliCommand("inner")
                             {
-                                new Option<bool>("-x")
+                                new CliOption<bool>("-x")
                             },
-                            new Option<bool>("-x")
+                            new CliOption<bool>("-x")
                         };
 
             ParseResult result = outer.Parse("outer inner -x");
@@ -679,10 +679,10 @@ public void When_options_with_the_same_name_are_defined_on_parent_and_child_comm
         [Fact]
         public void When_options_with_the_same_name_are_defined_on_parent_and_child_commands_and_specified_in_between_then_it_attaches_to_the_outer_command()
         {
-            var outer = new Command("outer");
-            outer.Options.Add(new Option<bool>("-x"));
-            var inner = new Command("inner");
-            inner.Options.Add(new Option<bool>("-x"));
+            var outer = new CliCommand("outer");
+            outer.Options.Add(new CliOption<bool>("-x"));
+            var inner = new CliCommand("inner");
+            inner.Options.Add(new CliOption<bool>("-x"));
             outer.Subcommands.Add(inner);
 
             var result = outer.Parse("outer -x inner");
@@ -704,12 +704,12 @@ public void When_options_with_the_same_name_are_defined_on_parent_and_child_comm
         [Fact]
         public void Arguments_only_apply_to_the_nearest_command()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Argument<string>("arg1"),
-                new Command("inner")
+                new CliArgument<string>("arg1"),
+                new CliCommand("inner")
                 {
-                    new Argument<string>("arg2")
+                    new CliArgument<string>("arg2")
                 }
             };
 
@@ -733,12 +733,12 @@ public void Arguments_only_apply_to_the_nearest_command()
         [Fact]
         public void Options_only_apply_to_the_nearest_command()
         {
-            var outerOption = new Option<string>("-x");
-            var innerOption = new Option<string>("-x");
+            var outerOption = new CliOption<string>("-x");
+            var innerOption = new CliOption<string>("-x");
 
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
                         {
-                            new Command("inner")
+                            new CliCommand("inner")
                             {
                                 innerOption
                             },
@@ -756,12 +756,12 @@ public void Options_only_apply_to_the_nearest_command()
         [Fact]
         public void Subsequent_occurrences_of_tokens_matching_command_names_are_parsed_as_arguments()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Command("complete")
+                new CliCommand("complete")
                 {
-                    new Argument<string>("arg"),
-                    new Option<int>("--position")
+                    new CliArgument<string>("arg"),
+                    new CliOption<int>("--position")
                 }
             };
 
@@ -782,9 +782,9 @@ public void Absolute_unix_style_paths_are_lexed_correctly()
             const string commandText =
                 @"rm ""/temp/the file.txt""";
 
-            Command command = new ("rm")
+            CliCommand command = new ("rm")
             {
-                new Argument<string[]>("arg")
+                new CliArgument<string[]>("arg")
             };
 
             var result = command.Parse(commandText);
@@ -802,9 +802,9 @@ public void Absolute_Windows_style_paths_are_lexed_correctly()
             const string commandText =
                 @"rm ""c:\temp\the file.txt\""";
 
-            Command command = new("rm")
+            CliCommand command = new("rm")
             {
-                new Argument<string[]>("arg")
+                new CliArgument<string[]>("arg")
             };
 
             ParseResult result = command.Parse(commandText);
@@ -818,12 +818,12 @@ public void Absolute_Windows_style_paths_are_lexed_correctly()
         [Fact]
         public void Commands_can_have_default_argument_values()
         {
-            var argument = new Argument<string>("the-arg")
+            var argument = new CliArgument<string>("the-arg")
             {
                 DefaultValueFactory = (_) => "default"
             };
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 argument
             };
@@ -838,8 +838,8 @@ public void Commands_can_have_default_argument_values()
         [Fact]
         public void When_an_option_with_a_default_value_is_not_matched_then_the_option_can_still_be_accessed_as_though_it_had_been_applied()
         {
-            var command = new Command("command");
-            var option = new Option<string>("-o", "--option")
+            var command = new CliCommand("command");
+            var option = new CliOption<string>("-o", "--option")
             {
                 DefaultValueFactory = (_) => "the-default"
             };
@@ -854,12 +854,12 @@ public void When_an_option_with_a_default_value_is_not_matched_then_the_option_c
         [Fact]
         public void When_an_option_with_a_default_value_is_not_matched_then_the_option_result_is_implicit()
         {
-            var option = new Option<string>("-o", "--option")
+            var option = new CliOption<string>("-o", "--option")
             {
                 DefaultValueFactory = (_) => "the-default"
             };
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 option
             };
@@ -867,7 +867,7 @@ public void When_an_option_with_a_default_value_is_not_matched_then_the_option_r
             var result = command.Parse("command");
 
             result.FindResultFor(option)
-                  .IsImplicit
+                  .Implicit
                   .Should()
                   .BeTrue();
         }
@@ -875,12 +875,12 @@ public void When_an_option_with_a_default_value_is_not_matched_then_the_option_r
         [Fact]
         public void When_an_option_with_a_default_value_is_not_matched_then_there_are_no_tokens()
         {
-            var option = new Option<string>("-o")
+            var option = new CliOption<string>("-o")
             {
                 DefaultValueFactory = (_) => "the-default"
             };
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 option
             };
@@ -896,12 +896,12 @@ public void When_an_option_with_a_default_value_is_not_matched_then_there_are_no
         [Fact]
         public void When_an_argument_with_a_default_value_is_not_matched_then_there_are_no_tokens()
         {
-            var argument = new Argument<string>("o")
+            var argument = new CliArgument<string>("o")
             {
                 DefaultValueFactory = (_) => "the-default"
             };
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 argument
             };
@@ -916,12 +916,12 @@ public void When_an_argument_with_a_default_value_is_not_matched_then_there_are_
         [Fact]
         public void Command_default_argument_value_does_not_override_parsed_value()
         {
-            var argument = new Argument<DirectoryInfo>("the-arg")
+            var argument = new CliArgument<DirectoryInfo>("the-arg")
             {
                 DefaultValueFactory = (_) => new DirectoryInfo(Directory.GetCurrentDirectory())
             };
 
-            var command = new Command("inner")
+            var command = new CliCommand("inner")
             {
                 argument
             };
@@ -937,11 +937,11 @@ public void Command_default_argument_value_does_not_override_parsed_value()
         [Fact]
         public void Unmatched_tokens_that_look_like_options_are_not_split_into_smaller_tokens()
         {
-            var outer = new Command("outer")
+            var outer = new CliCommand("outer")
             {
-                new Command("inner")
+                new CliCommand("inner")
                 {
-                    new Argument<string[]>("arg")
+                    new CliArgument<string[]>("arg")
                     {
                         Arity = ArgumentArity.OneOrMore
                     }
@@ -960,9 +960,9 @@ public void Unmatched_tokens_that_look_like_options_are_not_split_into_smaller_t
         [Fact]
         public void The_default_behavior_of_unmatched_tokens_resulting_in_errors_can_be_turned_off()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<string>("arg")
+                new CliArgument<string>("arg")
             };
             command.TreatUnmatchedTokensAsErrors = false;
 
@@ -978,18 +978,18 @@ public void The_default_behavior_of_unmatched_tokens_resulting_in_errors_can_be_
         [Fact]
         public void Option_and_Command_can_have_the_same_alias()
         {
-            var innerCommand = new Command("inner")
+            var innerCommand = new CliCommand("inner")
             {
-                new Argument<string[]>("arg1")
+                new CliArgument<string[]>("arg1")
             };
 
-            var option = new Option<bool>("--inner");
+            var option = new CliOption<bool>("--inner");
 
-            var outerCommand = new Command("outer")
+            var outerCommand = new CliCommand("outer")
             {
                 innerCommand,
                 option,
-                new Argument<string[]>("arg2")
+                new CliArgument<string[]>("arg2")
             };
 
             outerCommand.Parse("outer inner")
@@ -1024,10 +1024,10 @@ public void Option_and_Command_can_have_the_same_alias()
         [Fact]
         public void Options_can_have_the_same_alias_differentiated_only_by_prefix()
         {
-            var option1 = new Option<bool>("-a");
-            var option2 = new Option<bool>("--a");
+            var option1 = new CliOption<bool>("-a");
+            var option2 = new CliOption<bool>("--a");
 
-            var parser = new RootCommand
+            var parser = new CliRootCommand
             {
                 option1, 
                 option2
@@ -1056,9 +1056,9 @@ public void Options_can_have_the_same_alias_differentiated_only_by_prefix()
             string arg1,
             string arg2)
         {
-            var option = new Option<string[]>("-x");
+            var option = new CliOption<string[]>("-x");
 
-            var parseResult = new RootCommand { option }.Parse(new[] { arg1, arg2 });
+            var parseResult = new CliRootCommand { option }.Parse(new[] { arg1, arg2 });
 
             parseResult
                 .FindResultFor(option)
@@ -1071,11 +1071,11 @@ public void Options_can_have_the_same_alias_differentiated_only_by_prefix()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1445
         public void Trailing_option_delimiters_are_ignored()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
-                new Command("subcommand")
+                new CliCommand("subcommand")
                 {
-                    new Option<DirectoryInfo>("--directory")
+                    new CliOption<DirectoryInfo>("--directory")
                 }
             };
 
@@ -1097,12 +1097,12 @@ public void Trailing_option_delimiters_are_ignored()
         [InlineData("-x:-y")]
         public void Option_arguments_can_start_with_prefixes_that_make_them_look_like_options(string input)
         {
-            var optionX = new Option<string>("-x");
+            var optionX = new CliOption<string>("-x");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 optionX,
-                new Option<string>("-z")
+                new CliOption<string>("-z")
             };
 
             var result = command.Parse(input);
@@ -1113,11 +1113,11 @@ public void Option_arguments_can_start_with_prefixes_that_make_them_look_like_op
         [Fact]
         public void Option_arguments_can_start_with_prefixes_that_make_them_look_like_bundled_options()
         {
-            var optionA = new Option<string>("-a");
-            var optionB = new Option<bool>("-b");
-            var optionC = new Option<bool>("-c");
+            var optionA = new CliOption<string>("-a");
+            var optionB = new CliOption<bool>("-b");
+            var optionC = new CliOption<bool>("-c");
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionA,
                 optionB,
@@ -1134,10 +1134,10 @@ public void Option_arguments_can_start_with_prefixes_that_make_them_look_like_bu
         [Fact]
         public void Option_arguments_can_match_subcommands()
         {
-            var optionA = new Option<string>("-a");
-            var root = new RootCommand
+            var optionA = new CliOption<string>("-a");
+            var root = new CliRootCommand
             {
-                new Command("subcommand"),
+                new CliCommand("subcommand"),
                 optionA
             };
 
@@ -1152,12 +1152,12 @@ public void Option_arguments_can_match_subcommands()
         [Fact]
         public void Arguments_can_match_subcommands()
         {
-            var argument = new Argument<string[]>("arg");
-            var subcommand = new Command("subcommand")
+            var argument = new CliArgument<string[]>("arg");
+            var subcommand = new CliCommand("subcommand")
             {
                 argument
             };
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
                 subcommand
             };
@@ -1176,12 +1176,12 @@ public void Arguments_can_match_subcommands()
         [InlineData("-x:-y")]
         public void Option_arguments_can_match_the_aliases_of_sibling_options_when_non_space_argument_delimiter_is_used(string input)
         {
-            var optionX = new Option<string>("-x");
+            var optionX = new CliOption<string>("-x");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 optionX,
-                new Option<string>("-y")
+                new CliOption<string>("-y")
             };
 
             var result = command.Parse(input);
@@ -1193,9 +1193,9 @@ public void Option_arguments_can_match_the_aliases_of_sibling_options_when_non_s
         [Fact]
         public void Single_option_arguments_that_match_option_aliases_are_parsed_correctly()
         {
-            var optionX = new Option<string>("-x");
+            var optionX = new CliOption<string>("-x");
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionX
             };
@@ -1216,10 +1216,10 @@ public void Single_option_arguments_that_match_option_aliases_are_parsed_correct
         [InlineData("-x=true -y:true")]
         public void Boolean_options_are_not_greedy(string commandLine)
         {
-            var optX = new Option<bool>("-x");
-            var optY = new Option<bool>("-y");
+            var optX = new CliOption<bool>("-x");
+            var optY = new CliOption<bool>("-y");
 
-            var root = new RootCommand("parent")
+            var root = new CliRootCommand("parent")
             {
                 optX,
                 optY,
@@ -1236,10 +1236,10 @@ public void Boolean_options_are_not_greedy(string commandLine)
         [Fact]
         public void Multiple_option_arguments_that_match_multiple_arity_option_aliases_are_parsed_correctly()
         {
-            var optionX = new Option<string[]>("-x");
-            var optionY = new Option<string[]>("-y");
+            var optionX = new CliOption<string[]>("-x");
+            var optionY = new CliOption<string[]>("-y");
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionX,
                 optionY
@@ -1256,10 +1256,10 @@ public void Multiple_option_arguments_that_match_multiple_arity_option_aliases_a
         [Fact]
         public void Bundled_option_arguments_that_match_option_aliases_are_parsed_correctly()
         {
-            var optionX = new Option<string>("-x");
-            var optionY = new Option<bool>("-y");
+            var optionX = new CliOption<string>("-x");
+            var optionY = new CliOption<bool>("-y");
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 optionX,
                 optionY
@@ -1273,10 +1273,10 @@ public void Bundled_option_arguments_that_match_option_aliases_are_parsed_correc
         [Fact]
         public void Argument_name_is_not_matched_as_a_token()
         {
-            var nameArg = new Argument<string>("name");
-            var columnsArg = new Argument<IEnumerable<string>>("columns");
+            var nameArg = new CliArgument<string>("name");
+            var columnsArg = new CliArgument<IEnumerable<string>>("columns");
 
-            var command = new Command("add", "Adds a new series")
+            var command = new CliCommand("add", "Adds a new series")
             {
                 nameArg,
                 columnsArg
@@ -1291,9 +1291,9 @@ public void Argument_name_is_not_matched_as_a_token()
         [Fact]
         public void Option_aliases_do_not_need_to_be_prefixed()
         {
-            var option = new Option<bool>("noprefix");
+            var option = new CliOption<bool>("noprefix");
 
-            var result = new RootCommand { option }.Parse("noprefix");
+            var result = new CliRootCommand { option }.Parse("noprefix");
 
             result.FindResultFor(option).Should().NotBeNull();
         }
@@ -1301,9 +1301,9 @@ public void Option_aliases_do_not_need_to_be_prefixed()
         [Fact]
         public void Boolean_options_with_no_argument_specified_do_not_match_subsequent_arguments()
         {
-            var option = new Option<bool>("-v");
+            var option = new CliOption<bool>("-v");
 
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 option
             };
@@ -1316,13 +1316,13 @@ public void Boolean_options_with_no_argument_specified_do_not_match_subsequent_a
         [Fact]
         public void When_a_command_line_has_unmatched_tokens_they_are_not_applied_to_subsequent_options()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
                 TreatUnmatchedTokensAsErrors = false
             };
-            var optionX = new Option<string>("-x");
+            var optionX = new CliOption<string>("-x");
             command.Options.Add(optionX);
-            var optionY = new Option<string>("-y");
+            var optionY = new CliOption<string>("-y");
             command.Options.Add(optionY);
 
             var result = command.Parse("-x 23 unmatched-token -y 42");
@@ -1335,7 +1335,7 @@ public void When_a_command_line_has_unmatched_tokens_they_are_not_applied_to_sub
         [Fact]
         public void Parse_can_not_be_called_with_null_args()
         {
-            Action passNull = () => new RootCommand().Parse(args: null);
+            Action passNull = () => new CliRootCommand().Parse(args: null);
 
             passNull.Should().Throw<ArgumentNullException>();
         }
@@ -1343,11 +1343,11 @@ public void Parse_can_not_be_called_with_null_args()
         [Fact]
         public void Command_argument_arity_can_be_a_fixed_value_greater_than_1()
         {
-            var argument = new Argument<string[]>("arg")
+            var argument = new CliArgument<string[]>("arg")
             {
                 Arity = new ArgumentArity(3, 3)
             };
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 argument
             };
@@ -1365,11 +1365,11 @@ public void Command_argument_arity_can_be_a_fixed_value_greater_than_1()
         [Fact]
         public void Command_argument_arity_can_be_a_range_with_a_lower_bound_greater_than_1()
         {
-            var argument = new Argument<string[]>("arg")
+            var argument = new CliArgument<string[]>("arg")
             {
                 Arity = new ArgumentArity(3, 5)
             };
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 argument
             };
@@ -1397,9 +1397,9 @@ public void Command_argument_arity_can_be_a_range_with_a_lower_bound_greater_tha
         [Fact]
         public void When_command_arguments_are_fewer_than_minimum_arity_then_an_error_is_returned()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<string[]>("arg")
+                new CliArgument<string[]>("arg")
                 {
                     Arity = new ArgumentArity(2, 3)
                 }
@@ -1416,9 +1416,9 @@ public void When_command_arguments_are_fewer_than_minimum_arity_then_an_error_is
         [Fact]
         public void When_command_arguments_are_greater_than_maximum_arity_then_an_error_is_returned()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Argument<string[]>("arg")
+                new CliArgument<string[]>("arg")
                 {
                     Arity = new ArgumentArity(2, 3)
                 }
@@ -1436,9 +1436,9 @@ public void When_command_arguments_are_greater_than_maximum_arity_then_an_error_
         [Fact]
         public void Option_argument_arity_can_be_a_fixed_value_greater_than_1()
         {
-            var option = new Option<int[]>("-x") { Arity = new ArgumentArity(3, 3)};
+            var option = new CliOption<int[]>("-x") { Arity = new ArgumentArity(3, 3)};
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -1456,9 +1456,9 @@ public void Option_argument_arity_can_be_a_fixed_value_greater_than_1()
         [Fact]
         public void Option_argument_arity_can_be_a_range_with_a_lower_bound_greater_than_1()
         {
-            var option = new Option<string[]>("-x") { Arity = new ArgumentArity(3, 5) };
+            var option = new CliOption<string[]>("-x") { Arity = new ArgumentArity(3, 5) };
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -1486,12 +1486,12 @@ public void Option_argument_arity_can_be_a_range_with_a_lower_bound_greater_than
         [Fact]
         public void When_option_arguments_are_fewer_than_minimum_arity_then_an_error_is_returned()
         {
-            var option = new Option<int[]>("-x") 
+            var option = new CliOption<int[]>("-x") 
             { 
                 Arity = new ArgumentArity(2, 3)
             };
 
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
                 option
             };
@@ -1507,9 +1507,9 @@ public void When_option_arguments_are_fewer_than_minimum_arity_then_an_error_is_
         [Fact]
         public void When_option_arguments_are_greater_than_maximum_arity_then_an_error_is_returned()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<int[]>("-x") { Arity = new ArgumentArity(2, 3)}
+                new CliOption<int[]>("-x") { Arity = new ArgumentArity(2, 3)}
             };
 
             command.Parse("-x 1 2 3 4")
@@ -1522,8 +1522,8 @@ public void When_option_arguments_are_greater_than_maximum_arity_then_an_error_i
         [Fact]
         public void Tokens_are_not_split_if_the_part_before_the_delimiter_is_not_an_option()
         {
-            var rootCommand = new Command("jdbc");
-            rootCommand.Add(new Option<string>("url"));
+            var rootCommand = new CliCommand("jdbc");
+            rootCommand.Add(new CliOption<string>("url"));
             var result = rootCommand.Parse("jdbc url \"jdbc:sqlserver://10.0.0.2;databaseName=main\"");
 
             result.Tokens
@@ -1538,17 +1538,17 @@ public void A_subcommand_wont_overflow_when_checking_maximum_argument_capacity()
         {
             // Tests bug identified in https://github.com/dotnet/command-line-api/issues/997
 
-            var argument1 = new Argument<string>("arg1");
+            var argument1 = new CliArgument<string>("arg1");
 
-            var argument2 = new Argument<string[]>("arg2");
+            var argument2 = new CliArgument<string[]>("arg2");
 
-            var command = new Command("subcommand")
+            var command = new CliCommand("subcommand")
             {
                 argument1,
                 argument2
             };
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 command
             };
@@ -1565,12 +1565,12 @@ public void A_subcommand_wont_overflow_when_checking_maximum_argument_capacity()
         [InlineData("--exec-prefix=", "")]
         public void Parsed_value_of_empty_string_arg_is_an_empty_string(string arg1, string arg2)
         {
-            var option = new Option<string>("--exec-prefix")
+            var option = new CliOption<string>("--exec-prefix")
             {
                 DefaultValueFactory = (_) => "/usr/local"
             };
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 option
             };
diff --git a/src/System.CommandLine.Tests/ParsingValidationTests.cs b/src/System.CommandLine.Tests/ParsingValidationTests.cs
index bfce68fe99..b9723b3d62 100644
--- a/src/System.CommandLine.Tests/ParsingValidationTests.cs
+++ b/src/System.CommandLine.Tests/ParsingValidationTests.cs
@@ -24,10 +24,10 @@ public ParsingValidationTests(ITestOutputHelper output)
         [Fact]
         public void When_an_option_accepts_only_specific_arguments_but_a_wrong_one_is_supplied_then_an_informative_error_is_returned()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
             option.AcceptOnlyFromAmong("this", "that", "the-other-thing");
 
-            var result = new RootCommand { option }.Parse("-x none-of-those");
+            var result = new CliRootCommand { option }.Parse("-x none-of-those");
 
             result.Errors
                   .Select(e => e.Message)
@@ -40,10 +40,10 @@ public void When_an_option_accepts_only_specific_arguments_but_a_wrong_one_is_su
         [Fact]
         public void When_an_option_has_en_error_then_the_error_has_a_reference_to_the_option()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
             option.AcceptOnlyFromAmong("this", "that");
 
-            var result = new RootCommand { option }.Parse("-x something_else");
+            var result = new CliRootCommand { option }.Parse("-x something_else");
 
             result.Errors
                   .Where(e => e.SymbolResult != null)
@@ -54,9 +54,9 @@ public void When_an_option_has_en_error_then_the_error_has_a_reference_to_the_op
         [Fact] // https://github.com/dotnet/command-line-api/issues/1475
         public void When_FromAmong_is_used_then_the_OptionResult_ErrorMessage_is_set()
         {
-            var option = new Option<string>("--opt");
+            var option = new CliOption<string>("--opt");
             option.AcceptOnlyFromAmong("a", "b");
-            var command = new Command("test") { option };
+            var command = new CliCommand("test") { option };
 
             var parseResult = command.Parse("test --opt c");
 
@@ -76,10 +76,10 @@ public void When_FromAmong_is_used_then_the_OptionResult_ErrorMessage_is_set()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1475
         public void When_FromAmong_is_used_then_the_ArgumentResult_ErrorMessage_is_set()
         {
-            var argument = new Argument<string>("arg");
+            var argument = new CliArgument<string>("arg");
             argument.AcceptOnlyFromAmong("a", "b");
 
-            var command = new Command("test") { argument };
+            var command = new CliCommand("test") { argument };
 
             var parseResult = command.Parse("test c");
 
@@ -98,7 +98,7 @@ public void When_FromAmong_is_used_then_the_ArgumentResult_ErrorMessage_is_set()
         [Fact] // https://github.com/dotnet/command-line-api/issues/1556
         public void When_FromAmong_is_used_for_multiple_arguments_and_valid_input_is_provided_then_there_are_no_errors()
         {
-            var command = new Command("set")
+            var command = new CliCommand("set")
             {
                 CreateArgumentWithAcceptOnlyFromAmong(name: "key", "key1", "key2"),
                 CreateArgumentWithAcceptOnlyFromAmong(name : "value", "value1", "value2")
@@ -112,7 +112,7 @@ public void When_FromAmong_is_used_for_multiple_arguments_and_valid_input_is_pro
         [Fact]
         public void When_FromAmong_is_used_for_multiple_arguments_and_invalid_input_is_provided_for_the_first_one_then_the_error_is_informative()
         {
-            var command = new Command("set")
+            var command = new CliCommand("set")
             {
                 CreateArgumentWithAcceptOnlyFromAmong(name : "key", "key1", "key2"),
                 CreateArgumentWithAcceptOnlyFromAmong(name : "value", "value1", "value2")
@@ -132,10 +132,10 @@ public void When_FromAmong_is_used_for_multiple_arguments_and_invalid_input_is_p
         [Fact]
         public void When_FromAmong_is_used_multiple_times_only_the_most_recently_provided_values_are_taken_into_account()
         {
-            Argument<string> argument = new("key");
+            CliArgument<string> argument = new("key");
             argument.AcceptOnlyFromAmong("key1");
 
-            var command = new Command("set")
+            var command = new CliCommand("set")
             {
                 argument
             };
@@ -160,7 +160,7 @@ public void When_FromAmong_is_used_multiple_times_only_the_most_recently_provide
         [Fact]
         public void When_FromAmong_is_used_for_multiple_arguments_and_invalid_input_is_provided_for_the_second_one_then_the_error_is_informative()
         {
-            var command = new Command("set")
+            var command = new CliCommand("set")
             {
                 CreateArgumentWithAcceptOnlyFromAmong(name : "key", "key1", "key2"),
                 CreateArgumentWithAcceptOnlyFromAmong(name : "value", "value1", "value2")
@@ -180,12 +180,12 @@ public void When_FromAmong_is_used_for_multiple_arguments_and_invalid_input_is_p
         [Fact]
         public void When_FromAmong_is_used_and_multiple_invalid_inputs_are_provided_the_errors_mention_all_invalid_arguments()
         {
-            Option<string[]> option = new("--columns");
+            CliOption<string[]> option = new("--columns");
             option.AcceptOnlyFromAmong("author", "language", "tags", "type");
             option.Arity = new ArgumentArity(1, 4);
             option.AllowMultipleArgumentsPerToken = true;
 
-            var command = new Command("list")
+            var command = new CliCommand("list")
             {
                 option
             };
@@ -208,9 +208,9 @@ public void When_FromAmong_is_used_and_multiple_invalid_inputs_are_provided_the_
         [Fact]
         public void When_a_required_argument_is_not_supplied_then_an_error_is_returned()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
 
-            var result = new RootCommand { option }.Parse("-x");
+            var result = new CliRootCommand { option }.Parse("-x");
 
             result.Errors
                   .Should()
@@ -222,11 +222,11 @@ public void When_a_required_argument_is_not_supplied_then_an_error_is_returned()
         [Fact]
         public void When_a_required_option_is_not_supplied_then_an_error_is_returned()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Option<string>("-x")
+                new CliOption<string>("-x")
                 {
-                    IsRequired = true
+                    Required = true
                 }
             };
 
@@ -246,11 +246,11 @@ public void When_a_required_option_is_not_supplied_then_an_error_is_returned()
         [Fact]
         public void When_a_required_option_has_multiple_aliases_the_error_message_uses_the_name()
         {
-            var command = new Command("command")
+            var command = new CliCommand("command")
             {
-                new Option<string>("--xray", "-x")
+                new CliOption<string>("--xray", "-x")
                 {
-                    IsRequired = true
+                    Required = true
                 }
             };
 
@@ -272,15 +272,15 @@ public void When_a_required_option_has_multiple_aliases_the_error_message_uses_t
         [InlineData("-x arg subcommand")]
         public void When_a_required_option_is_allowed_at_more_than_one_position_it_only_needs_to_be_satisfied_in_one(string commandLine)
         {
-            var option = new Option<string>("-x")
+            var option = new CliOption<string>("-x")
             {
-                IsRequired = true
+                Required = true
             };
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 option,
-                new Command("subcommand")
+                new CliCommand("subcommand")
                 {
                     option
                 }
@@ -294,11 +294,11 @@ public void When_a_required_option_is_allowed_at_more_than_one_position_it_only_
         [Fact]
         public void Required_options_on_parent_commands_do_not_create_parse_errors_when_an_inner_command_is_specified()
         {
-            var child = new Command("child");
+            var child = new CliCommand("child");
 
-            var parent = new Command("parent")
+            var parent = new CliCommand("parent")
             {
-                new Option<string>("-x") { IsRequired = true },
+                new CliOption<string>("-x") { Required = true },
                 child
             };
 
@@ -311,9 +311,9 @@ public void Required_options_on_parent_commands_do_not_create_parse_errors_when_
         public void When_no_option_accepts_arguments_but_one_is_supplied_then_an_error_is_returned()
         {
             var command =
-                new Command("the-command")
+                new CliCommand("the-command")
                 {
-                    new Option<bool>("-x")
+                    new CliOption<bool>("-x")
                     {
                         Arity = ArgumentArity.Zero
                     }
@@ -334,10 +334,10 @@ public void When_no_option_accepts_arguments_but_one_is_supplied_then_an_error_i
         [Fact]
         public void A_custom_validator_can_be_added_to_a_command()
         {
-            var command = new Command("the-command")
+            var command = new CliCommand("the-command")
             {
-                new Option<bool>("--one"),
-                new Option<bool>("--two")
+                new CliOption<bool>("--one"),
+                new CliOption<bool>("--two")
             };
 
             command.Validators.Add(commandResult =>
@@ -363,7 +363,7 @@ public void A_custom_validator_can_be_added_to_a_command()
         [Fact]
         public void A_custom_validator_can_be_added_to_an_option()
         {
-            var option = new Option<int>("-x");
+            var option = new CliOption<int>("-x");
 
             option.Validators.Add(r =>
             {
@@ -372,7 +372,7 @@ public void A_custom_validator_can_be_added_to_an_option()
                 r.AddError($"Option {r.IdentifierToken.Value} cannot be set to {value}");
             });
 
-            var command = new RootCommand { option };
+            var command = new CliRootCommand { option };
 
             var result = command.Parse("-x 123");
 
@@ -390,7 +390,7 @@ public void A_custom_validator_can_be_added_to_an_option()
         [Fact]
         public void A_custom_validator_can_be_added_to_an_argument()
         {
-            var argument = new Argument<int>("x");
+            var argument = new CliArgument<int>("x");
 
             argument.Validators.Add(r =>
             {
@@ -399,7 +399,7 @@ public void A_custom_validator_can_be_added_to_an_argument()
                 r.AddError($"Argument {r.Argument.Name} cannot be set to {value}");
             });
 
-            var command = new RootCommand { argument };
+            var command = new CliRootCommand { argument };
 
             var result = command.Parse("123");
 
@@ -423,19 +423,19 @@ public void All_custom_validators_are_called(string commandLine)
             var optionValidatorWasCalled = false;
             var argumentValidatorWasCalled = false;
 
-            var option = new Option<string>("-o");
+            var option = new CliOption<string>("-o");
             option.Validators.Add(_ =>
             {
                 optionValidatorWasCalled = true;
             });
 
-            var argument = new Argument<string>("the-arg");
+            var argument = new CliArgument<string>("the-arg");
             argument.Validators.Add(_ =>
             {
                 argumentValidatorWasCalled = true;
             });
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 option,
                 argument
@@ -457,14 +457,14 @@ public void All_custom_validators_are_called(string commandLine)
         [InlineData("subcommand --file \"Foo\"")]
         public void Validators_on_global_options_are_executed_when_invoking_a_subcommand(string commandLine)
         {
-            var option = new Option<FileInfo>("--file") { AppliesToSelfAndChildren = true };
+            var option = new CliOption<FileInfo>("--file") { Recursive = true };
             option.Validators.Add(r =>
             {
                 r.AddError("Invoked validator");
             });
 
-            var subCommand = new Command("subcommand");
-            var rootCommand = new RootCommand 
+            var subCommand = new CliCommand("subcommand");
+            var rootCommand = new CliRootCommand 
             {
                 subCommand
             };
@@ -494,20 +494,20 @@ public async Task A_custom_validator_added_to_a_global_option_is_checked(string
         {
             var handlerWasCalled = false;
 
-            var globalOption = new Option<int>("--value")
+            var globalOption = new CliOption<int>("--value")
             { 
-                AppliesToSelfAndChildren = true
+                Recursive = true
             };
 
             globalOption.Validators.Add(r => r.AddError("oops!"));
 
-            var grandchildCommand = new Command("grandchild");
+            var grandchildCommand = new CliCommand("grandchild");
 
-            var childCommand = new Command("child")
+            var childCommand = new CliCommand("child")
             {
                 grandchildCommand
             };
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 childCommand
             };
@@ -528,10 +528,10 @@ public async Task A_custom_validator_added_to_a_global_option_is_checked(string
         public void Custom_validator_error_messages_are_not_repeated()
         {
             var errorMessage = "that's not right...";
-            var argument = new Argument<string>("arg");
+            var argument = new CliArgument<string>("arg");
             argument.Validators.Add(r => r.AddError(errorMessage));
 
-            var cmd = new Command("get")
+            var cmd = new CliCommand("get")
             {
                 argument
             };
@@ -548,7 +548,7 @@ public void Custom_validator_error_messages_are_not_repeated()
         [Fact]
         public void The_parsed_value_of_an_argument_is_available_within_a_validator()
         {
-            var argument = new Argument<int>("arg");
+            var argument = new CliArgument<int>("arg");
             var errorMessage = "The value of option '-x' must be between 1 and 100.";
             argument.Validators.Add(result =>
             {
@@ -560,7 +560,7 @@ public void The_parsed_value_of_an_argument_is_available_within_a_validator()
                 }
             });
 
-            var result = new RootCommand() { argument }.Parse("-1");
+            var result = new CliRootCommand() { argument }.Parse("-1");
 
             result.Errors
                   .Should()
@@ -572,7 +572,7 @@ public void The_parsed_value_of_an_argument_is_available_within_a_validator()
         [Fact]
         public void The_parsed_value_of_an_option_is_available_within_a_validator()
         {
-            var option = new Option<int>("-x");
+            var option = new CliOption<int>("-x");
             var errorMessage = "The value of option '-x' must be between 1 and 100.";
             option.Validators.Add(result =>
             {
@@ -584,7 +584,7 @@ public void The_parsed_value_of_an_option_is_available_within_a_validator()
                 }
             });
 
-            var result = new RootCommand { option }.Parse("-x -1");
+            var result = new CliRootCommand { option }.Parse("-x -1");
 
             result.Errors
                   .Should()
@@ -598,9 +598,9 @@ public class PathValidity
             [Fact]
             public void LegalFilePathsOnly_rejects_command_arguments_containing_invalid_path_characters()
             {
-                Argument<string> argument = new("arg");
+                CliArgument<string> argument = new("arg");
                 argument.AcceptLegalFilePathsOnly();
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     argument
                 };
@@ -620,9 +620,9 @@ public void LegalFilePathsOnly_rejects_command_arguments_containing_invalid_path
             [Fact]
             public void LegalFilePathsOnly_rejects_option_arguments_containing_invalid_path_characters()
             {
-                Option<string> option = new ("-x");
+                CliOption<string> option = new ("-x");
                 option.AcceptLegalFilePathsOnly();
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     option
                 };
@@ -642,9 +642,9 @@ public void LegalFilePathsOnly_rejects_option_arguments_containing_invalid_path_
             [Fact]
             public void LegalFilePathsOnly_accepts_command_arguments_containing_valid_path_characters()
             {
-                Argument<string[]> argument = new ("arg");
+                CliArgument<string[]> argument = new ("arg");
                 argument.AcceptLegalFilePathsOnly();
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     argument
                 };
@@ -660,10 +660,10 @@ public void LegalFilePathsOnly_accepts_command_arguments_containing_valid_path_c
             [Fact]
             public void LegalFilePathsOnly_accepts_option_arguments_containing_valid_path_characters()
             {
-                Option<string[]> option = new ("-x");
+                CliOption<string[]> option = new ("-x");
                 option.AcceptLegalFilePathsOnly();
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     option
                 };
@@ -682,10 +682,10 @@ public class FileNameValidity
             [Fact]
             public void LegalFileNamesOnly_rejects_command_arguments_containing_invalid_file_name_characters()
             {
-                Argument<string> argument = new("arg");
+                CliArgument<string> argument = new("arg");
                 argument.AcceptLegalFileNamesOnly();
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     argument
                 };
@@ -705,10 +705,10 @@ public void LegalFileNamesOnly_rejects_command_arguments_containing_invalid_file
             [Fact]
             public void LegalFileNamesOnly_rejects_option_arguments_containing_invalid_file_name_characters()
             {
-                Option<string> option = new("-x");
+                CliOption<string> option = new("-x");
                 option.AcceptLegalFileNamesOnly();
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     option
                 };
@@ -728,10 +728,10 @@ public void LegalFileNamesOnly_rejects_option_arguments_containing_invalid_file_
             [Fact]
             public void LegalFileNamesOnly_accepts_command_arguments_containing_valid_file_name_characters()
             {
-                Argument<string[]> argument = new ("arg");
+                CliArgument<string[]> argument = new ("arg");
                 argument.AcceptLegalFileNamesOnly();
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     argument
                 };
@@ -747,10 +747,10 @@ public void LegalFileNamesOnly_accepts_command_arguments_containing_valid_file_n
             [Fact]
             public void LegalFileNamesOnly_accepts_option_arguments_containing_valid_file_name_characters()
             {
-                Option<string[]> option = new("-x");
+                CliOption<string[]> option = new("-x");
                 option.AcceptLegalFileNamesOnly();
 
-                var command = new Command("the-command")
+                var command = new CliCommand("the-command")
                 {
                     option
                 };
@@ -769,9 +769,9 @@ public class FileExistence
             [Fact]
             public void A_command_argument_can_be_invalid_based_on_file_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<FileInfo>("to").AcceptExistingOnly()
+                    new CliArgument<FileInfo>("to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -788,9 +788,9 @@ public void A_command_argument_can_be_invalid_based_on_file_existence()
             [Fact]
             public void An_option_argument_can_be_invalid_based_on_file_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<FileInfo>("--to").AcceptExistingOnly()
+                    new CliOption<FileInfo>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -807,9 +807,9 @@ public void An_option_argument_can_be_invalid_based_on_file_existence()
             [Fact]
             public void A_command_argument_can_be_invalid_based_on_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<DirectoryInfo>("to").AcceptExistingOnly()
+                    new CliArgument<DirectoryInfo>("to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -826,9 +826,9 @@ public void A_command_argument_can_be_invalid_based_on_directory_existence()
             [Fact]
             public void An_option_argument_can_be_invalid_based_on_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<DirectoryInfo>("--to").AcceptExistingOnly()
+                    new CliOption<DirectoryInfo>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -845,9 +845,9 @@ public void An_option_argument_can_be_invalid_based_on_directory_existence()
             [Fact]
             public void A_command_argument_can_be_invalid_based_on_file_or_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<FileSystemInfo>("arg").AcceptExistingOnly()
+                    new CliArgument<FileSystemInfo>("arg").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -864,9 +864,9 @@ public void A_command_argument_can_be_invalid_based_on_file_or_directory_existen
             [Fact]
             public void An_option_argument_can_be_invalid_based_on_file_or_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<FileSystemInfo>("--to").AcceptExistingOnly()
+                    new CliOption<FileSystemInfo>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -883,9 +883,9 @@ public void An_option_argument_can_be_invalid_based_on_file_or_directory_existen
             [Fact]
             public void A_command_argument_with_multiple_files_can_be_invalid_based_on_file_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<IEnumerable<FileInfo>>("to").AcceptExistingOnly()
+                    new CliArgument<IEnumerable<FileInfo>>("to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -902,9 +902,9 @@ public void A_command_argument_with_multiple_files_can_be_invalid_based_on_file_
             [Fact]
             public void An_option_argument_with_multiple_files_can_be_invalid_based_on_file_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<IEnumerable<FileInfo>>("--to").AcceptExistingOnly()
+                    new CliOption<IEnumerable<FileInfo>>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -921,9 +921,9 @@ public void An_option_argument_with_multiple_files_can_be_invalid_based_on_file_
             [Fact]
             public void A_command_argument_with_multiple_directories_can_be_invalid_based_on_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<List<DirectoryInfo>>("to").AcceptExistingOnly()
+                    new CliArgument<List<DirectoryInfo>>("to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -940,9 +940,9 @@ public void A_command_argument_with_multiple_directories_can_be_invalid_based_on
             [Fact]
             public void An_option_argument_with_multiple_directories_can_be_invalid_based_on_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<DirectoryInfo[]>("--to").AcceptExistingOnly()
+                    new CliOption<DirectoryInfo[]>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -959,13 +959,13 @@ public void An_option_argument_with_multiple_directories_can_be_invalid_based_on
             [Fact]
             public void A_command_argument_with_multiple_FileSystemInfos_can_be_invalid_based_on_file_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<FileSystemInfo[]>("to")
+                    new CliArgument<FileSystemInfo[]>("to")
                     {
                         Arity = ArgumentArity.ZeroOrMore
                     }.AcceptExistingOnly(),
-                    new Option<string>("--to")
+                    new CliOption<string>("--to")
                 };
 
                 var path = NonexistentPath();
@@ -980,9 +980,9 @@ public void A_command_argument_with_multiple_FileSystemInfos_can_be_invalid_base
             [Fact]
             public void An_option_argument_with_multiple_FileSystemInfos_can_be_invalid_based_on_file_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<FileSystemInfo[]>("--to").AcceptExistingOnly()
+                    new CliOption<FileSystemInfo[]>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -999,9 +999,9 @@ public void An_option_argument_with_multiple_FileSystemInfos_can_be_invalid_base
             [Fact]
             public void A_command_argument_with_multiple_FileSystemInfos_can_be_invalid_based_on_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<FileSystemInfo>("to").AcceptExistingOnly()
+                    new CliArgument<FileSystemInfo>("to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -1018,9 +1018,9 @@ public void A_command_argument_with_multiple_FileSystemInfos_can_be_invalid_base
             [Fact]
             public void An_option_argument_with_multiple_FileSystemInfos_can_be_invalid_based_on_directory_existence()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<FileSystemInfo[]>("--to").AcceptExistingOnly()
+                    new CliOption<FileSystemInfo[]>("--to").AcceptExistingOnly()
                 };
 
                 var path = NonexistentPath();
@@ -1037,9 +1037,9 @@ public void An_option_argument_with_multiple_FileSystemInfos_can_be_invalid_base
             [Fact]
             public void Command_argument_does_not_return_errors_when_file_exists()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<FileInfo>("arg").AcceptExistingOnly()
+                    new CliArgument<FileInfo>("arg").AcceptExistingOnly()
                 };
 
                 var path = ExistingFile();
@@ -1051,9 +1051,9 @@ public void Command_argument_does_not_return_errors_when_file_exists()
             [Fact]
             public void Option_argument_does_not_return_errors_when_file_exists()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<FileInfo>("--to").AcceptExistingOnly()
+                    new CliOption<FileInfo>("--to").AcceptExistingOnly()
                 };
 
                 var path = ExistingFile();
@@ -1065,9 +1065,9 @@ public void Option_argument_does_not_return_errors_when_file_exists()
             [Fact]
             public void Command_argument_does_not_return_errors_when_Directory_exists()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Argument<DirectoryInfo>("arg").AcceptExistingOnly()
+                    new CliArgument<DirectoryInfo>("arg").AcceptExistingOnly()
                 };
 
                 var path = ExistingDirectory();
@@ -1079,9 +1079,9 @@ public void Command_argument_does_not_return_errors_when_Directory_exists()
             [Fact]
             public void Option_argument_does_not_return_errors_when_Directory_exists()
             {
-                var command = new Command("move")
+                var command = new CliCommand("move")
                 {
-                    new Option<DirectoryInfo>("--to").AcceptExistingOnly()
+                    new CliOption<DirectoryInfo>("--to").AcceptExistingOnly()
                 };
 
                 var path = ExistingDirectory();
@@ -1109,9 +1109,9 @@ private string ExistingFile()
         [Fact]
         public void A_command_with_subcommands_is_invalid_to_invoke_if_it_has_no_handler()
         {
-            var outer = new Command("outer");
-            var inner = new Command("inner");
-            var innerer = new Command("inner-er");
+            var outer = new CliCommand("outer");
+            var inner = new CliCommand("inner");
+            var innerer = new CliCommand("inner-er");
             outer.Subcommands.Add(inner);
             inner.Subcommands.Add(innerer);
 
@@ -1127,8 +1127,8 @@ public void A_command_with_subcommands_is_invalid_to_invoke_if_it_has_no_handler
         [Fact]
         public void A_root_command_is_invalid_if_it_has_no_handler()
         {
-            var rootCommand = new RootCommand();
-            var inner = new Command("inner");
+            var rootCommand = new CliRootCommand();
+            var inner = new CliCommand("inner");
             rootCommand.Add(inner);
 
             var result = rootCommand.Parse("");
@@ -1143,10 +1143,10 @@ public void A_root_command_is_invalid_if_it_has_no_handler()
         [Fact]
         public void A_command_with_subcommands_is_valid_to_invoke_if_it_has_a_handler()
         {
-            var outer = new Command("outer");
-            var inner = new Command("inner");
+            var outer = new CliCommand("outer");
+            var inner = new CliCommand("inner");
             inner.SetAction((_) => { });
-            var innerer = new Command("inner-er");
+            var innerer = new CliCommand("inner-er");
             outer.Subcommands.Add(inner);
             inner.Subcommands.Add(innerer);
 
@@ -1159,9 +1159,9 @@ public void A_command_with_subcommands_is_valid_to_invoke_if_it_has_a_handler()
         [Fact]
         public void When_an_option_has_a_default_value_it_is_not_valid_to_specify_the_option_without_an_argument()
         {
-            var option = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var option = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
 
-            var result = new RootCommand { option }.Parse("-x");
+            var result = new CliRootCommand { option }.Parse("-x");
 
             result.Errors
                   .Select(e => e.Message)
@@ -1172,10 +1172,10 @@ public void When_an_option_has_a_default_value_it_is_not_valid_to_specify_the_op
         [Fact]
         public void When_an_option_has_a_default_value_then_the_default_should_apply_if_not_specified()
         {
-            var optionX = new Option<int>("-x") { DefaultValueFactory = (_) => 123 };
-            var optionY = new Option<int>("-y") { DefaultValueFactory = (_) => 456 };
+            var optionX = new CliOption<int>("-x") { DefaultValueFactory = (_) => 123 };
+            var optionY = new CliOption<int>("-y") { DefaultValueFactory = (_) => 456 };
 
-            var parser = new RootCommand
+            var parser = new CliRootCommand
             {
                 optionX,
                 optionY
@@ -1191,9 +1191,9 @@ public void When_an_option_has_a_default_value_then_the_default_should_apply_if_
         [Fact] // https://github.com/dotnet/command-line-api/issues/1505
         public void Arity_failures_are_not_reported_for_both_an_argument_and_its_parent_option()
         {
-            var newCommand = new Command("test")
+            var newCommand = new CliCommand("test")
             {
-                new Option<string>("--opt")
+                new CliOption<string>("--opt")
             };
 
             var parseResult = newCommand.Parse("test --opt");
@@ -1210,7 +1210,7 @@ public void Arity_failures_are_not_reported_for_both_an_argument_and_its_parent_
         [Fact] // https://github.com/dotnet/command-line-api/issues/1573
         public void Multiple_validators_on_the_same_command_do_not_report_duplicate_errors()
         {
-            var command = new RootCommand();
+            var command = new CliRootCommand();
             command.Validators.Add(result => result.AddError("Wrong"));
             command.Validators.Add(_ => { });
 
@@ -1228,11 +1228,11 @@ public void Multiple_validators_on_the_same_command_do_not_report_duplicate_erro
         [Fact] // https://github.com/dotnet/command-line-api/issues/1573
         public void Multiple_validators_on_the_same_option_do_not_report_duplicate_errors()
         {
-            var option = new Option<string>("-x");
+            var option = new CliOption<string>("-x");
             option.Validators.Add(result => result.AddError("Wrong"));
             option.Validators.Add(_ => { });
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 option
             };
@@ -1251,11 +1251,11 @@ public void Multiple_validators_on_the_same_option_do_not_report_duplicate_error
         [Fact] // https://github.com/dotnet/command-line-api/issues/1573
         public void Multiple_validators_on_the_same_argument_do_not_report_duplicate_errors()
         {
-            var argument = new Argument<string>("arg");
+            var argument = new CliArgument<string>("arg");
             argument.Validators.Add(result => result.AddError("Wrong"));
             argument.Validators.Add(_ => { });
 
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
                 argument
             };
@@ -1274,13 +1274,13 @@ public void Multiple_validators_on_the_same_argument_do_not_report_duplicate_err
         [Fact] // https://github.com/dotnet/command-line-api/issues/1609
         internal void When_there_is_an_arity_error_then_further_errors_are_not_reported()
         {
-            var option = new Option<string>("-o");
+            var option = new CliOption<string>("-o");
             option.Validators.Add(result =>
             {
                 result.AddError("OOPS");
             }); //all good;
 
-            var command = new Command("comm")
+            var command = new CliCommand("comm")
             {
                 option
             };
@@ -1296,9 +1296,9 @@ internal void When_there_is_an_arity_error_then_further_errors_are_not_reported(
                        .Be("Required argument missing for option: '-o'.");
         }
 
-        private Argument<string> CreateArgumentWithAcceptOnlyFromAmong(string name, params string[] values)
+        private CliArgument<string> CreateArgumentWithAcceptOnlyFromAmong(string name, params string[] values)
         {
-            Argument<string> argument = new(name);
+            CliArgument<string> argument = new(name);
             argument.AcceptOnlyFromAmong(values);
             return argument;
         }
diff --git a/src/System.CommandLine.Tests/ResponseFileTests.cs b/src/System.CommandLine.Tests/ResponseFileTests.cs
index de8e26e8e2..89db0e90c5 100644
--- a/src/System.CommandLine.Tests/ResponseFileTests.cs
+++ b/src/System.CommandLine.Tests/ResponseFileTests.cs
@@ -43,9 +43,9 @@ private string CreateResponseFile(params string[] lines)
         [Fact]
         public void When_response_file_specified_it_loads_options_from_response_file()
         {
-            var option = new Option<bool>("--flag");
+            var option = new CliOption<bool>("--flag");
 
-            var result = new RootCommand { option }.Parse($"@{CreateResponseFile("--flag")}");
+            var result = new CliRootCommand { option }.Parse($"@{CreateResponseFile("--flag")}");
 
             result.FindResultFor(option).Should().NotBeNull();
         }
@@ -58,10 +58,10 @@ public void When_response_file_is_specified_it_loads_options_with_arguments_from
                 "--flag2",
                 "123");
 
-            var optionOne = new Option<bool>("--flag");
+            var optionOne = new CliOption<bool>("--flag");
 
-            var optionTwo = new Option<int>("--flag2");
-            var result = new RootCommand
+            var optionTwo = new CliOption<int>("--flag2");
+            var result = new CliRootCommand
                          {
                              optionOne,
                              optionTwo
@@ -81,9 +81,9 @@ public void When_response_file_is_specified_it_loads_command_arguments_from_resp
                 "two",
                 "three");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
             {
-                new Argument<string[]>("arg")
+                new CliArgument<string[]>("arg")
             }
             .Parse($"@{responseFile}");
 
@@ -102,11 +102,11 @@ public void Response_file_can_provide_subcommand_arguments()
                 "two",
                 "three");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
                          {
-                             new Command("subcommand")
+                             new CliCommand("subcommand")
                              {
-                                 new Argument<string[]>("arg")
+                                 new CliArgument<string[]>("arg")
                              }
                          }
                 .Parse($"subcommand @{responseFile}");
@@ -123,11 +123,11 @@ public void Response_file_can_provide_subcommand()
         {
             var responseFile = CreateResponseFile("subcommand");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
                          {
-                             new Command("subcommand")
+                             new CliCommand("subcommand")
                              {
-                                 new Argument<string[]>("arg")
+                                 new CliArgument<string[]>("arg")
                              }
                          }
                 .Parse($"@{responseFile} one two three");
@@ -147,11 +147,11 @@ public void When_response_file_is_specified_it_loads_subcommand_arguments_from_r
                 "two",
                 "three");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
                          {
-                             new Command("subcommand")
+                             new CliCommand("subcommand")
                              {
-                                 new Argument<string[]>("arg")
+                                 new CliArgument<string[]>("arg")
                              }
                          }
                 .Parse($"subcommand @{responseFile}");
@@ -171,9 +171,9 @@ public void Response_file_can_contain_blank_lines()
                 "",
                 "123");
 
-            var option = new Option<int>("--flag");
+            var option = new CliOption<int>("--flag");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
                 {
                     option
                 }
@@ -186,8 +186,8 @@ public void Response_file_can_contain_blank_lines()
         [Fact]
         public void Response_file_can_contain_comments_which_are_ignored_when_loaded()
         {
-            var optionOne = new Option<bool>("--flag");
-            var optionTwo = new Option<bool>("--flag2");
+            var optionOne = new CliOption<bool>("--flag");
+            var optionTwo = new CliOption<bool>("--flag2");
 
             var responseFile = CreateResponseFile(
                 "# comment one",
@@ -197,7 +197,7 @@ public void Response_file_can_contain_comments_which_are_ignored_when_loaded()
                 " # comment two",
                 "--flag2");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
             {
                 optionOne,
                 optionTwo
@@ -211,10 +211,10 @@ public void Response_file_can_contain_comments_which_are_ignored_when_loaded()
         [Fact]
         public void When_response_file_does_not_exist_then_error_is_returned()
         {
-            var optionOne = new Option<bool>("--flag");
-            var optionTwo = new Option<bool>("--flag2");
+            var optionOne = new CliOption<bool>("--flag");
+            var optionTwo = new CliOption<bool>("--flag2");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
                          {
                              optionOne,
                              optionTwo
@@ -229,10 +229,10 @@ public void When_response_file_does_not_exist_then_error_is_returned()
         [Fact]
         public void When_response_filepath_is_not_specified_then_error_is_returned()
         {
-            var optionOne = new Option<bool>("--flag");
-            var optionTwo = new Option<bool>("--flag2");
+            var optionOne = new CliOption<bool>("--flag");
+            var optionTwo = new CliOption<bool>("--flag2");
 
-            var result = new RootCommand
+            var result = new CliRootCommand
                          {
                              optionOne,
                              optionTwo
@@ -253,12 +253,12 @@ public void When_response_filepath_is_not_specified_then_error_is_returned()
         public void When_response_file_cannot_be_read_then_specified_error_is_returned()
         {
             var nonexistent = Path.GetTempFileName();
-            var optionOne = new Option<bool>("--flag");
-            var optionTwo = new Option<bool>("--flag2");
+            var optionOne = new CliOption<bool>("--flag");
+            var optionTwo = new CliOption<bool>("--flag2");
 
             using (File.Open(nonexistent, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
             {
-                var result = new RootCommand
+                var result = new CliRootCommand
                              {
                                  optionOne,
                                  optionTwo
@@ -279,10 +279,10 @@ public void When_response_file_parse_as_space_separated_returns_expected_values(
         {
             var responseFile = CreateResponseFile(input);
 
-            var optionOne = new Option<string>("--flag");
-            var optionTwo = new Option<int>("--flag2");
+            var optionOne = new CliOption<string>("--flag");
+            var optionTwo = new CliOption<int>("--flag2");
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 optionOne,
                 optionTwo
@@ -298,9 +298,9 @@ public void When_response_file_parse_as_space_separated_returns_expected_values(
         [Fact]
         public void When_response_file_processing_is_disabled_then_it_returns_response_file_name_as_argument()
         {
-            RootCommand command = new ()
+            CliRootCommand command = new ()
             {
-                new Argument<List<string>>("arg")
+                new CliArgument<List<string>>("arg")
             };
             CommandLineConfiguration configuration = new(command)
             {
@@ -323,11 +323,11 @@ public void Response_files_can_refer_to_other_response_files()
             var file2 = CreateResponseFile($"@{file3}", "--two", "2");
             var file1 = CreateResponseFile("--one", "1", $"@{file2}");
 
-            var option1 = new Option<int>("--one");
-            var option2 = new Option<int>("--two");
-            var option3 = new Option<int>("--three");
+            var option1 = new CliOption<int>("--one");
+            var option2 = new CliOption<int>("--two");
+            var option3 = new CliOption<int>("--three");
 
-            var command = new RootCommand
+            var command = new CliRootCommand
                           {
                               option1,
                               option2,
@@ -348,10 +348,10 @@ public void When_response_file_options_or_arguments_contain_trailing_spaces_they
         {
             var responseFile = CreateResponseFile("--option1 ", "value1 ", "--option2\t", "2\t");
 
-            var option1 = new Option<string>("--option1");
-            var option2 = new Option<int>("--option2");
+            var option1 = new CliOption<string>("--option1");
+            var option2 = new CliOption<int>("--option2");
 
-            var result = new RootCommand { option1, option2 }.Parse($"@{responseFile}");
+            var result = new CliRootCommand { option1, option2 }.Parse($"@{responseFile}");
             result.GetValue(option1).Should().Be("value1");
             result.GetValue(option2).Should().Be(2);
         }
@@ -361,10 +361,10 @@ public void When_response_file_options_or_arguments_contain_leading_spaces_they_
         {
             var responseFile = CreateResponseFile(" --option1", " value1", "\t--option2", "\t2");
 
-            var option1 = new Option<string>("--option1");
-            var option2 = new Option<int>("--option2");
+            var option1 = new CliOption<string>("--option1");
+            var option2 = new CliOption<int>("--option2");
 
-            var result = new RootCommand { option1, option2 }.Parse($"@{responseFile}");
+            var result = new CliRootCommand { option1, option2 }.Parse($"@{responseFile}");
             result.GetValue(option1).Should().Be("value1");
             result.GetValue(option2).Should().Be(2);
             result.Errors.Should().BeEmpty();
@@ -375,10 +375,10 @@ public void When_response_file_options_or_arguments_contain_trailing_and_leading
         {
             var responseFile = CreateResponseFile(" --option1 ", " value1 ", "\t--option2\t", "\t2\t");
 
-            var option1 = new Option<string>("--option1");
-            var option2 = new Option<int>("--option2");
+            var option1 = new CliOption<string>("--option1");
+            var option2 = new CliOption<int>("--option2");
 
-            var result = new RootCommand { option1, option2 }.Parse($"@{responseFile}");
+            var result = new CliRootCommand { option1, option2 }.Parse($"@{responseFile}");
             result.GetValue(option1).Should().Be("value1");
             result.GetValue(option2).Should().Be(2);
             result.Errors.Should().BeEmpty();
diff --git a/src/System.CommandLine.Tests/RootCommandTests.cs b/src/System.CommandLine.Tests/RootCommandTests.cs
index 664d976106..e129e9fee4 100644
--- a/src/System.CommandLine.Tests/RootCommandTests.cs
+++ b/src/System.CommandLine.Tests/RootCommandTests.cs
@@ -11,9 +11,9 @@ public class RootCommandTests
         [Fact]
         public void Root_command_name_defaults_to_executable_name()
         {
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
 
-            rootCommand.Name.Should().Be(RootCommand.ExecutableName);
+            rootCommand.Name.Should().Be(CliRootCommand.ExecutableName);
         }
     }
 }
diff --git a/src/System.CommandLine.Tests/SuggestDirectiveTests.cs b/src/System.CommandLine.Tests/SuggestDirectiveTests.cs
index 5b60a817ee..a4eda60d9c 100644
--- a/src/System.CommandLine.Tests/SuggestDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/SuggestDirectiveTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.CommandLine.Completions;
 using System.CommandLine.Help;
 using System.IO;
 using System.Threading.Tasks;
@@ -12,21 +13,21 @@ namespace System.CommandLine.Tests
 {
     public class SuggestDirectiveTests
     {
-        protected Option _fruitOption;
+        protected CliOption _fruitOption;
 
-        protected Option _vegetableOption;
+        protected CliOption _vegetableOption;
 
-        private readonly Command _eatCommand;
+        private readonly CliCommand _eatCommand;
 
         public SuggestDirectiveTests()
         {
-            _fruitOption = new Option<string>("--fruit");
+            _fruitOption = new CliOption<string>("--fruit");
             _fruitOption.CompletionSources.Add("apple", "banana", "cherry");
 
-            _vegetableOption = new Option<string>("--vegetable");
+            _vegetableOption = new CliOption<string>("--vegetable");
             _vegetableOption.CompletionSources.Add(_ => new[] { "asparagus", "broccoli", "carrot" });
 
-            _eatCommand = new Command("eat")
+            _eatCommand = new CliCommand("eat")
             {
                 _fruitOption,
                 _vegetableOption
@@ -36,7 +37,7 @@ public SuggestDirectiveTests()
         [Fact]
         public async Task It_writes_suggestions_for_option_arguments_when_under_subcommand()
         {
-            RootCommand rootCommand = new () { _eatCommand };
+            CliRootCommand rootCommand = new () { _eatCommand };
             CommandLineConfiguration config = new (rootCommand)
             {
                 Output = new StringWriter(),
@@ -56,7 +57,7 @@ public async Task It_writes_suggestions_for_option_arguments_when_under_subcomma
         [Fact]
         public async Task It_writes_suggestions_for_option_arguments_when_under_root_command()
         {
-            RootCommand rootCommand = new ()
+            CliRootCommand rootCommand = new ()
             {
                 _fruitOption,
                 _vegetableOption
@@ -82,7 +83,7 @@ public async Task It_writes_suggestions_for_option_arguments_when_under_root_com
         [InlineData("[suggest:6] \"eat --\"")]
         public async Task It_writes_suggestions_for_option_aliases_under_subcommand(string commandLine)
         {
-            RootCommand rootCommand = new() { _eatCommand };
+            CliRootCommand rootCommand = new() { _eatCommand };
             CommandLineConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
@@ -106,7 +107,7 @@ public async Task It_writes_suggestions_for_option_aliases_under_subcommand(stri
         [InlineData("[suggest:0] ")]
         public async Task It_writes_suggestions_for_option_aliases_under_root_command(string input)
         {
-            RootCommand rootCommand = new()
+            CliRootCommand rootCommand = new()
             {
                 _vegetableOption,
                 _fruitOption
@@ -129,7 +130,7 @@ public async Task It_writes_suggestions_for_option_aliases_under_root_command(st
         [Fact]
         public async Task It_writes_suggestions_for_subcommand_aliases_under_root_command()
         {
-            RootCommand rootCommand = new() { _eatCommand };
+            CliRootCommand rootCommand = new() { _eatCommand };
             CommandLineConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
@@ -148,7 +149,7 @@ public async Task It_writes_suggestions_for_subcommand_aliases_under_root_comman
         [Fact]
         public async Task It_writes_suggestions_for_partial_option_aliases_under_root_command()
         {
-            RootCommand rootCommand = new()
+            CliRootCommand rootCommand = new()
             {
                 _fruitOption,
                 _vegetableOption
@@ -172,10 +173,10 @@ public async Task It_writes_suggestions_for_partial_option_aliases_under_root_co
         [Fact]
         public async Task It_writes_suggestions_for_partial_subcommand_aliases_under_root_command()
         {
-            RootCommand rootCommand = new ()
+            CliRootCommand rootCommand = new ()
             {
                 _eatCommand,
-                new Command("wash-dishes")
+                new CliCommand("wash-dishes")
             };
             CommandLineConfiguration config = new (rootCommand)
             {
@@ -196,10 +197,10 @@ public async Task It_writes_suggestions_for_partial_subcommand_aliases_under_roo
         [Fact]
         public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliases_under_root_command()
         {
-            RootCommand rootCommand = new ()
+            CliRootCommand rootCommand = new ()
             {
                 _eatCommand,
-                new Command("wash-dishes"),
+                new CliCommand("wash-dishes"),
             };
             CommandLineConfiguration config = new (rootCommand)
             {
@@ -220,12 +221,12 @@ public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliase
         [Fact]
         public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliases_under_root_command_with_an_argument()
         {
-            Command command = new("parent")
+            CliCommand command = new("parent")
             {
-                new Command("child"),
-                new Option<bool>("--option1"),
-                new Option<bool>("--option2"),
-                new Argument<string>("arg")
+                new CliCommand("child"),
+                new CliOption<bool>("--option1"),
+                new CliOption<bool>("--option2"),
+                new CliArgument<string>("arg")
             };
             CommandLineConfiguration config = new (command)
             {
@@ -244,9 +245,9 @@ public async Task It_writes_suggestions_for_partial_option_and_subcommand_aliase
         [Fact]
         public async Task It_does_not_repeat_suggestion_for_already_specified_bool_option()
         {
-            var command = new RootCommand
+            var command = new CliRootCommand
             {
-                new Option<bool>("--bool-option")
+                new CliOption<bool>("--bool-option")
             };
             CommandLineConfiguration config = new (command)
             {
diff --git a/src/System.CommandLine.Tests/TestApps/NativeAOT/Program.cs b/src/System.CommandLine.Tests/TestApps/NativeAOT/Program.cs
index ccc111f88d..15ee25d129 100644
--- a/src/System.CommandLine.Tests/TestApps/NativeAOT/Program.cs
+++ b/src/System.CommandLine.Tests/TestApps/NativeAOT/Program.cs
@@ -6,10 +6,10 @@ public class Program
 {
     private static int Main(string[] args)
     {
-        Option<bool> boolOption = new Option<bool>("--bool", "-b") { Description = "Bool option" };
-        Option<string> stringOption = new Option<string>("--string", "-s") { Description = "String option" };
+        CliOption<bool> boolOption = new ("--bool", "-b") { Description = "Bool option" };
+        CliOption<string> stringOption = new ("--string", "-s") { Description = "String option" };
 
-        RootCommand command = new RootCommand
+        CliRootCommand command = new ()
         {
             boolOption,
             stringOption
diff --git a/src/System.CommandLine.Tests/TestApps/Trimming/Program.cs b/src/System.CommandLine.Tests/TestApps/Trimming/Program.cs
index 4a7b10dbe8..2fe399296a 100644
--- a/src/System.CommandLine.Tests/TestApps/Trimming/Program.cs
+++ b/src/System.CommandLine.Tests/TestApps/Trimming/Program.cs
@@ -1,10 +1,10 @@
 using System.CommandLine;
 using System.CommandLine.Invocation;
 
-var fileArgument = new Argument<FileInfo>("file");
+CliArgument<FileInfo> fileArgument = new ("file");
 fileArgument.AcceptLegalFileNamesOnly();
 
-var command = new RootCommand
+CliRootCommand command = new ()
 {
     fileArgument
 };
diff --git a/src/System.CommandLine.Tests/TokenReplacementTests.cs b/src/System.CommandLine.Tests/TokenReplacementTests.cs
index c96af9b0c2..2045728a97 100644
--- a/src/System.CommandLine.Tests/TokenReplacementTests.cs
+++ b/src/System.CommandLine.Tests/TokenReplacementTests.cs
@@ -12,9 +12,9 @@ public class TokenReplacementTests
     [Fact]
     public void Token_replacer_receives_the_token_from_the_command_line_with_the_leading_at_symbol_removed()
     {
-        var argument = new Argument<int>("arg");
+        var argument = new CliArgument<int>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         string receivedToken = null;
 
@@ -37,9 +37,9 @@ public void Token_replacer_receives_the_token_from_the_command_line_with_the_lea
     [Fact]
     public void Token_replacer_can_expand_argument_values()
     {
-        var argument = new Argument<int>("arg");
+        var argument = new CliArgument<int>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         CommandLineConfiguration config = new(command)
         {
@@ -61,9 +61,9 @@ public void Token_replacer_can_expand_argument_values()
     [Fact]
     public void Custom_token_replacer_can_expand_option_argument_values()
     {
-        var option = new Option<int>("-x");
+        var option = new CliOption<int>("-x");
 
-        var command = new RootCommand { option };
+        var command = new CliRootCommand { option };
 
         CommandLineConfiguration config = new(command)
         {
@@ -85,9 +85,9 @@ public void Custom_token_replacer_can_expand_option_argument_values()
     [Fact]
     public void Custom_token_replacer_can_expand_subcommands_and_options_and_argument()
     {
-        var option = new Option<int>("-x");
+        var option = new CliOption<int>("-x");
 
-        var command = new RootCommand { new Command("subcommand") { option } };
+        var command = new CliRootCommand { new CliCommand("subcommand") { option } };
 
         CommandLineConfiguration config = new(command)
         {
@@ -109,9 +109,9 @@ public void Custom_token_replacer_can_expand_subcommands_and_options_and_argumen
     [Fact]
     public void Expanded_tokens_containing_whitespace_are_parsed_as_single_tokens()
     {
-        var argument = new Argument<string>("arg");
+        var argument = new CliArgument<string>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         CommandLineConfiguration config = new(command)
         {
@@ -131,9 +131,9 @@ public void Expanded_tokens_containing_whitespace_are_parsed_as_single_tokens()
     [Fact]
     public void Token_replacer_can_set_a_custom_error_message()
     {
-        var argument = new Argument<string>("arg");
+        var argument = new CliArgument<string>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         CommandLineConfiguration config = new(command)
         {
@@ -155,9 +155,9 @@ public void Token_replacer_can_set_a_custom_error_message()
     [Fact]
     public void When_token_replacer_returns_false_without_setting_an_error_message_then_the_command_line_is_unchanged_and_no_parse_error_is_produced()
     {
-        var argument = new Argument<string>("arg");
+        var argument = new CliArgument<string>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         CommandLineConfiguration config = new(command)
         {
@@ -179,9 +179,9 @@ public void When_token_replacer_returns_false_without_setting_an_error_message_t
     [Fact]
     public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets_tokens_to_null()
     {
-        var argument = new Argument<string[]>("arg");
+        var argument = new CliArgument<string[]>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         CommandLineConfiguration config = new(command)
         {
@@ -203,9 +203,9 @@ public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets
     [Fact]
     public void Token_replacer_will_delete_token_when_delegate_returns_true_and_sets_tokens_to_empty_array()
     {
-        var argument = new Argument<string[]>("arg");
+        var argument = new CliArgument<string[]>("arg");
 
-        var command = new RootCommand { argument };
+        var command = new CliRootCommand { argument };
 
         CommandLineConfiguration config = new(command)
         {
diff --git a/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs b/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs
index 5acf4b59b5..e8e18ddada 100644
--- a/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs
+++ b/src/System.CommandLine.Tests/UseExceptionHandlerTests.cs
@@ -13,7 +13,7 @@ public class UseExceptionHandlerTests
         [Fact]
         public async Task UseExceptionHandler_catches_command_handler_exceptions_and_sets_result_code_to_1()
         {
-            var command = new Command("the-command");
+            var command = new CliCommand("the-command");
             command.SetAction((_, __) => Task.FromException<int>(new Exception("oops!")));
 
             CommandLineConfiguration config = new(command)
@@ -29,7 +29,7 @@ public async Task UseExceptionHandler_catches_command_handler_exceptions_and_set
         [Fact]
         public async Task UseExceptionHandler_catches_command_handler_exceptions_and_writes_details_to_standard_error()
         {
-            var command = new Command("the-command");
+            var command = new CliCommand("the-command");
             command.SetAction((_, __) => Task.FromException<int>(new Exception("oops!")));
 
             CommandLineConfiguration config = new(command)
@@ -45,7 +45,7 @@ public async Task UseExceptionHandler_catches_command_handler_exceptions_and_wri
         [Fact]
         public async Task When_thrown_exception_is_from_cancelation_no_output_is_generated()
         {
-            Command command = new("the-command");
+            CliCommand command = new("the-command");
             command.SetAction((_, __) => throw new OperationCanceledException());
 
             CommandLineConfiguration config = new(command)
@@ -67,7 +67,7 @@ public async Task When_thrown_exception_is_from_cancelation_no_output_is_generat
         public async Task Exception_output_can_be_customized(bool async)
         {
             Exception expectedException = new ("oops!");
-            Command command = new("the-command");
+            CliCommand command = new("the-command");
             command.SetAction((_, __) => throw expectedException);
 
             CommandLineConfiguration config = new(command)
diff --git a/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs b/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs
index d3c8552940..29f1723a4d 100644
--- a/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs
+++ b/src/System.CommandLine.Tests/UseParseErrorReportingTests.cs
@@ -16,9 +16,9 @@ public class UseParseErrorReportingTests
         [Fact] // https://github.com/dotnet/command-line-api/issues/817
         public void Parse_error_reporting_reports_error_when_help_is_used_and_required_subcommand_is_missing()
         {
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
-                new Command("inner"),
+                new CliCommand("inner"),
                 new HelpOption()
             };
 
@@ -39,9 +39,9 @@ public void Parse_error_reporting_reports_error_when_help_is_used_and_required_s
         [Fact]
         public void User_can_customize_parse_error_result_code()
         {
-            var root = new RootCommand
+            var root = new CliRootCommand
             {
-                new Command("inner")
+                new CliCommand("inner")
             };
 
             CommandLineConfiguration config = new (root)
diff --git a/src/System.CommandLine.Tests/Utility/ParseResultExtensions.cs b/src/System.CommandLine.Tests/Utility/ParseResultExtensions.cs
index 0dcd118425..cdce6b2bc3 100644
--- a/src/System.CommandLine.Tests/Utility/ParseResultExtensions.cs
+++ b/src/System.CommandLine.Tests/Utility/ParseResultExtensions.cs
@@ -11,7 +11,7 @@ internal static string Diagram(this ParseResult parseResult)
             try
             {
                 parseResult.Configuration.Output = new StringWriter();
-                new ParseDirective().Action.Invoke(parseResult);
+                new ParseDiagramDirective().Action.Invoke(parseResult);
                 return parseResult.Configuration.Output.ToString()
                     .TrimEnd(); // the directive adds a new line, tests that used to rely on Diagram extension method don't expect it
             }
diff --git a/src/System.CommandLine.Tests/VersionOptionTests.cs b/src/System.CommandLine.Tests/VersionOptionTests.cs
index 4db6e86733..9ac35001dd 100644
--- a/src/System.CommandLine.Tests/VersionOptionTests.cs
+++ b/src/System.CommandLine.Tests/VersionOptionTests.cs
@@ -21,7 +21,7 @@ public class VersionOptionTests
         [Fact]
         public async Task When_the_version_option_is_specified_then_the_version_is_written_to_standard_out()
         {
-            CommandLineConfiguration configuration = new(new RootCommand())
+            CommandLineConfiguration configuration = new(new CliRootCommand())
             {
                 Output = new StringWriter()
             };
@@ -35,7 +35,7 @@ public async Task When_the_version_option_is_specified_then_the_version_is_writt
         public async Task When_the_version_option_is_specified_then_invocation_is_short_circuited()
         {
             var wasCalled = false;
-            var rootCommand = new RootCommand();
+            var rootCommand = new CliRootCommand();
             rootCommand.SetAction((_) => wasCalled = true);
 
             CommandLineConfiguration configuration = new(rootCommand)
@@ -51,7 +51,7 @@ public async Task When_the_version_option_is_specified_then_invocation_is_short_
         [Fact]
         public async Task Version_option_appears_in_help()
         {
-            CommandLineConfiguration configuration = new(new RootCommand())
+            CommandLineConfiguration configuration = new(new CliRootCommand())
             {
                 Output = new StringWriter()
             };
@@ -67,9 +67,9 @@ public async Task Version_option_appears_in_help()
         [Fact]
         public async Task When_the_version_option_is_specified_and_there_are_default_options_then_the_version_is_written_to_standard_out()
         {
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
-                new Option<bool>("-x")
+                new CliOption<bool>("-x")
                 {
                     DefaultValueFactory = (_) => true
                 },
@@ -89,9 +89,9 @@ public async Task When_the_version_option_is_specified_and_there_are_default_opt
         [Fact]
         public async Task When_the_version_option_is_specified_and_there_are_default_arguments_then_the_version_is_written_to_standard_out()
         {
-            RootCommand rootCommand = new ()
+            CliRootCommand rootCommand = new ()
             {
-                new Argument<bool>("x") { DefaultValueFactory =(_) => true },
+                new CliArgument<bool>("x") { DefaultValueFactory =(_) => true },
             };
             rootCommand.SetAction((_) => { });
 
@@ -110,12 +110,12 @@ public async Task When_the_version_option_is_specified_and_there_are_default_arg
         [InlineData("--version subcommand")]
         public void Version_is_not_valid_with_other_tokens(string commandLine)
         {
-            var subcommand = new Command("subcommand");
+            var subcommand = new CliCommand("subcommand");
             subcommand.SetAction((_) => { });
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 subcommand,
-                new Option<bool>("-x"),
+                new CliOption<bool>("-x"),
             };
             rootCommand.SetAction((_) => { });
 
@@ -132,10 +132,10 @@ public void Version_is_not_valid_with_other_tokens(string commandLine)
         [Fact]
         public void Version_option_is_not_added_to_subcommands()
         {
-            var childCommand = new Command("subcommand");
+            var childCommand = new CliCommand("subcommand");
             childCommand.SetAction((_) => { });
 
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 childCommand
             };
@@ -158,7 +158,7 @@ public void Version_option_is_not_added_to_subcommands()
         [Fact]
         public async Task Version_can_specify_additional_alias()
         {
-            RootCommand rootCommand = new();
+            CliRootCommand rootCommand = new();
 
             for (int i = 0; i < rootCommand.Options.Count; i++)
             {
@@ -182,9 +182,9 @@ public async Task Version_can_specify_additional_alias()
         [Fact]
         public void Version_is_not_valid_with_other_tokens_uses_custom_alias()
         {
-            var childCommand = new Command("subcommand");
+            var childCommand = new CliCommand("subcommand");
             childCommand.SetAction((_) => { });
-            var rootCommand = new RootCommand
+            var rootCommand = new CliRootCommand
             {
                 childCommand
             };
diff --git a/src/System.CommandLine/AliasSet.cs b/src/System.CommandLine/AliasSet.cs
index 0fed8a5d75..6007007843 100644
--- a/src/System.CommandLine/AliasSet.cs
+++ b/src/System.CommandLine/AliasSet.cs
@@ -14,7 +14,7 @@ internal AliasSet(string[] aliases)
         {
             foreach (string alias in aliases)
             {
-                Symbol.ThrowIfEmptyOrWithWhitespaces(alias, nameof(alias));
+                CliSymbol.ThrowIfEmptyOrWithWhitespaces(alias, nameof(alias));
             }
 
             _aliases = new(aliases, StringComparer.Ordinal);
@@ -25,7 +25,7 @@ internal AliasSet(string[] aliases)
         public bool IsReadOnly => false;
 
         public void Add(string item)
-            => _aliases.Add(Symbol.ThrowIfEmptyOrWithWhitespaces(item, nameof(item)));
+            => _aliases.Add(CliSymbol.ThrowIfEmptyOrWithWhitespaces(item, nameof(item)));
 
         internal bool Overlaps(AliasSet other) => _aliases.Overlaps(other._aliases);
 
diff --git a/src/System.CommandLine/ArgumentArity.cs b/src/System.CommandLine/ArgumentArity.cs
index f65e8b4f0a..9ce34855c2 100644
--- a/src/System.CommandLine/ArgumentArity.cs
+++ b/src/System.CommandLine/ArgumentArity.cs
@@ -49,12 +49,12 @@ public ArgumentArity(int minimumNumberOfValues, int maximumNumberOfValues)
         }
 
         /// <summary>
-        /// Gets the minimum number of values required for an <see cref="Argument">argument</see>.
+        /// Gets the minimum number of values required for an <see cref="CliArgument">argument</see>.
         /// </summary>
         public int MinimumNumberOfValues { get; }
 
         /// <summary>
-        /// Gets the maximum number of values allowed for an <see cref="Argument">argument</see>.
+        /// Gets the maximum number of values allowed for an <see cref="CliArgument">argument</see>.
         /// </summary>
         public int MaximumNumberOfValues { get; }
 
@@ -77,7 +77,7 @@ internal static bool Validate(ArgumentResult argumentResult, [NotNullWhen(false)
         {
             error = null;
 
-            if (argumentResult.Parent is null || argumentResult.Parent is OptionResult { IsImplicit: true })
+            if (argumentResult.Parent is null || argumentResult.Parent is OptionResult { Implicit: true })
             {
                 return true;
             }
@@ -142,7 +142,7 @@ internal static bool Validate(ArgumentResult argumentResult, [NotNullWhen(false)
         /// </summary>
         public static ArgumentArity OneOrMore => new(1, MaximumArity);
 
-        internal static ArgumentArity Default(Argument argument, ParentNode? firstParent)
+        internal static ArgumentArity Default(CliArgument argument, ParentNode? firstParent)
         {
             if (argument.IsBoolean())
             {
@@ -154,12 +154,12 @@ internal static ArgumentArity Default(Argument argument, ParentNode? firstParent
 
             if (type != typeof(string) && typeof(IEnumerable).IsAssignableFrom(type))
             {
-                return parent is Command
+                return parent is CliCommand
                            ? ZeroOrMore
                            : OneOrMore;
             }
 
-            if (parent is Command &&
+            if (parent is CliCommand &&
                 (argument.HasDefaultValue ||
                  type.IsNullable()))
             {
diff --git a/src/System.CommandLine/ArgumentValidation.cs b/src/System.CommandLine/ArgumentValidation.cs
index 00988ed1f9..f5a418c5d8 100644
--- a/src/System.CommandLine/ArgumentValidation.cs
+++ b/src/System.CommandLine/ArgumentValidation.cs
@@ -8,7 +8,7 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// Provides extension methods for <see cref="Argument" />.
+    /// Provides extension methods for <see cref="CliArgument" />.
     /// </summary>
     public static class ArgumentValidation
     {
@@ -17,7 +17,7 @@ public static class ArgumentValidation
         /// </summary>
         /// <param name="argument">The argument to configure.</param>
         /// <returns>The configured argument.</returns>
-        public static Argument<FileInfo> AcceptExistingOnly(this Argument<FileInfo> argument)
+        public static CliArgument<FileInfo> AcceptExistingOnly(this CliArgument<FileInfo> argument)
         {
             argument.Validators.Add(FileOrDirectoryExists<FileInfo>);
             return argument;
@@ -28,7 +28,7 @@ public static Argument<FileInfo> AcceptExistingOnly(this Argument<FileInfo> argu
         /// </summary>
         /// <param name="argument">The argument to configure.</param>
         /// <returns>The configured argument.</returns>
-        public static Argument<DirectoryInfo> AcceptExistingOnly(this Argument<DirectoryInfo> argument)
+        public static CliArgument<DirectoryInfo> AcceptExistingOnly(this CliArgument<DirectoryInfo> argument)
         {
             argument.Validators.Add(FileOrDirectoryExists<DirectoryInfo>);
             return argument;
@@ -39,7 +39,7 @@ public static Argument<DirectoryInfo> AcceptExistingOnly(this Argument<Directory
         /// </summary>
         /// <param name="argument">The argument to configure.</param>
         /// <returns>The configured argument.</returns>
-        public static Argument<FileSystemInfo> AcceptExistingOnly(this Argument<FileSystemInfo> argument)
+        public static CliArgument<FileSystemInfo> AcceptExistingOnly(this CliArgument<FileSystemInfo> argument)
         {
             argument.Validators.Add(FileOrDirectoryExists<FileSystemInfo>);
             return argument;
@@ -50,7 +50,7 @@ public static Argument<FileSystemInfo> AcceptExistingOnly(this Argument<FileSyst
         /// </summary>
         /// <param name="argument">The argument to configure.</param>
         /// <returns>The configured argument.</returns>
-        public static Argument<T> AcceptExistingOnly<T>(this Argument<T> argument)
+        public static CliArgument<T> AcceptExistingOnly<T>(this CliArgument<T> argument)
             where T : IEnumerable<FileSystemInfo>
         {
             if (typeof(IEnumerable<FileInfo>).IsAssignableFrom(typeof(T)))
diff --git a/src/System.CommandLine/Argument{T}.cs b/src/System.CommandLine/Argument{T}.cs
index 269da60b37..112b884c69 100644
--- a/src/System.CommandLine/Argument{T}.cs
+++ b/src/System.CommandLine/Argument{T}.cs
@@ -8,8 +8,8 @@
 
 namespace System.CommandLine
 {
-    /// <inheritdoc cref="Argument" />
-    public class Argument<T> : Argument
+    /// <inheritdoc cref="CliArgument" />
+    public class CliArgument<T> : CliArgument
     {
         private Func<ArgumentResult, T>? _customParser;
 
@@ -17,7 +17,7 @@ public class Argument<T> : Argument
         /// Initializes a new instance of the Argument class.
         /// </summary>
         /// <param name="name">The name of the argument. It's not used for parsing, only when displaying Help or creating parse errors.</param>>
-        public Argument(string name) : base(name)
+        public CliArgument(string name) : base(name)
         {
         }
 
diff --git a/src/System.CommandLine/Binding/ArgumentConverter.cs b/src/System.CommandLine/Binding/ArgumentConverter.cs
index cea514e48d..84adf4169c 100644
--- a/src/System.CommandLine/Binding/ArgumentConverter.cs
+++ b/src/System.CommandLine/Binding/ArgumentConverter.cs
@@ -117,7 +117,7 @@ internal static partial class ArgumentConverter
             return Success(argumentResult, values);
         }
 
-        internal static TryConvertArgument? GetConverter(Argument argument)
+        internal static TryConvertArgument? GetConverter(CliArgument argument)
         {
             if (argument.Arity is { MaximumNumberOfValues: 1, MinimumNumberOfValues: 1 })
             {
diff --git a/src/System.CommandLine/ChildList.cs b/src/System.CommandLine/ChildSymbolList{T}.cs
similarity index 90%
rename from src/System.CommandLine/ChildList.cs
rename to src/System.CommandLine/ChildSymbolList{T}.cs
index 21a0a2e66e..6289d5e49c 100644
--- a/src/System.CommandLine/ChildList.cs
+++ b/src/System.CommandLine/ChildSymbolList{T}.cs
@@ -9,12 +9,12 @@ namespace System.CommandLine
     /// <summary>
     /// a wrapper of List<typeparamref name="T"/> that sets parent for every added element
     /// </summary>
-    internal sealed class ChildList<T> : IList<T> where T : Symbol
+    internal sealed class ChildSymbolList<T> : IList<T> where T : CliSymbol
     {
         private readonly List<T> _children;
-        private readonly Command _parent;
+        private readonly CliCommand _parent;
 
-        public ChildList(Command parent)
+        public ChildSymbolList(CliCommand parent)
         {
             _parent = parent;
             _children = new();
diff --git a/src/System.CommandLine/Argument.cs b/src/System.CommandLine/CliArgument.cs
similarity index 92%
rename from src/System.CommandLine/Argument.cs
rename to src/System.CommandLine/CliArgument.cs
index 2462cebc4e..868dcb1cff 100644
--- a/src/System.CommandLine/Argument.cs
+++ b/src/System.CommandLine/CliArgument.cs
@@ -10,16 +10,16 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// A symbol defining a value that can be passed on the command line to a <see cref="Command">command</see> or <see cref="Option">option</see>.
+    /// A symbol defining a value that can be passed on the command line to a <see cref="CliCommand">command</see> or <see cref="CliOption">option</see>.
     /// </summary>
-    public abstract class Argument : Symbol
+    public abstract class CliArgument : CliSymbol
     {
         private ArgumentArity _arity;
         private TryConvertArgument? _convertArguments;
         private List<Func<CompletionContext, IEnumerable<CompletionItem>>>? _completionSources = null;
         private List<Action<ArgumentResult>>? _validators = null;
 
-        private protected Argument(string name) : base(name, allowWhitespace: true)
+        private protected CliArgument(string name) : base(name, allowWhitespace: true)
         {
         }
 
@@ -90,7 +90,7 @@ public ArgumentArity Arity
         }
 
         /// <summary>
-        /// Gets or sets the <see cref="Type" /> that the argument token(s) will be converted to.
+        /// Gets or sets the <see cref="Type" /> that the argument's parsed tokens will be converted to.
         /// </summary>
         public abstract Type ValueType { get; }
 
@@ -128,7 +128,7 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
         }
 
         /// <inheritdoc />
-        public override string ToString() => $"{nameof(Argument)}: {Name}";
+        public override string ToString() => $"{nameof(CliArgument)}: {Name}";
 
         internal bool IsBoolean() => ValueType == typeof(bool) || ValueType == typeof(bool?);
     }
diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/CliCommand.cs
similarity index 90%
rename from src/System.CommandLine/Command.cs
rename to src/System.CommandLine/CliCommand.cs
index 596ff23702..b81d7291e0 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/CliCommand.cs
@@ -18,15 +18,15 @@ namespace System.CommandLine
     /// </summary>
     /// <remarks>
     /// Use the Command object for actions that correspond to a specific string (the command name). See
-    /// <see cref="RootCommand"/> for simple applications that only have one action. For example, <c>dotnet run</c>
+    /// <see cref="CliRootCommand"/> for simple applications that only have one action. For example, <c>dotnet run</c>
     /// uses <c>run</c> as the command.
     /// </remarks>
-    public class Command : Symbol, IEnumerable<Symbol>
+    public class CliCommand : CliSymbol, IEnumerable<CliSymbol>
     {
         internal AliasSet? _aliases;
-        private ChildList<Argument>? _arguments;
-        private ChildList<Option>? _options;
-        private ChildList<Command>? _subcommands;
+        private ChildSymbolList<CliArgument>? _arguments;
+        private ChildSymbolList<CliOption>? _options;
+        private ChildSymbolList<CliCommand>? _subcommands;
         private List<Action<CommandResult>>? _validators;
 
         /// <summary>
@@ -34,13 +34,13 @@ public class Command : Symbol, IEnumerable<Symbol>
         /// </summary>
         /// <param name="name">The name of the command.</param>
         /// <param name="description">The description of the command, shown in help.</param>
-        public Command(string name, string? description = null) : base(name)
+        public CliCommand(string name, string? description = null) : base(name)
             => Description = description;
 
         /// <summary>
         /// Gets the child symbols.
         /// </summary>
-        public IEnumerable<Symbol> Children
+        public IEnumerable<CliSymbol> Children
         {
             get
             {
@@ -58,21 +58,21 @@ public IEnumerable<Symbol> Children
         /// <summary>
         /// Represents all of the arguments for the command.
         /// </summary>
-        public IList<Argument> Arguments => _arguments ??= new(this);
+        public IList<CliArgument> Arguments => _arguments ??= new(this);
 
         internal bool HasArguments => _arguments is not null && _arguments.Count > 0 ;
 
         /// <summary>
         /// Represents all of the options for the command, including global options that have been applied to any of the command's ancestors.
         /// </summary>
-        public IList<Option> Options => _options ??= new (this);
+        public IList<CliOption> Options => _options ??= new (this);
 
         internal bool HasOptions => _options is not null && _options.Count > 0;
 
         /// <summary>
         /// Represents all of the subcommands for the command.
         /// </summary>
-        public IList<Command> Subcommands => _subcommands ??= new(this);
+        public IList<CliCommand> Subcommands => _subcommands ??= new(this);
 
         internal bool HasSubcommands => _subcommands is not null && _subcommands.Count > 0;
 
@@ -87,7 +87,7 @@ public IEnumerable<Symbol> Children
         /// <summary>
         /// Gets the unique set of strings that can be used on the command line to specify the command.
         /// </summary>
-        /// <remarks>The collection does not contain the <see cref="Symbol.Name"/> of the Command.</remarks>
+        /// <remarks>The collection does not contain the <see cref="CliSymbol.Name"/> of the Command.</remarks>
         public ICollection<string> Aliases => _aliases ??= new();
 
         /// <summary>
@@ -163,23 +163,23 @@ public void SetAction(Func<ParseResult, CancellationToken, Task<int>> action)
         }
 
         /// <summary>
-        /// Adds a <see cref="Symbol"/> to the command.
+        /// Adds a <see cref="CliSymbol"/> to the command.
         /// </summary>
         /// <param name="symbol">The symbol to add to the command.</param>
         [EditorBrowsable(EditorBrowsableState.Never)] // hide from intellisense, it's public for C# duck typing
-        public void Add(Symbol symbol)
+        public void Add(CliSymbol symbol)
         {
             // this method exists so users can use C# duck typing for adding symbols to the Command:
             // new Command { option };
             switch (symbol)
             {
-                case Option option:
+                case CliOption option:
                     Options.Add(option);
                     break;
-                case Argument argument:
+                case CliArgument argument:
                     Arguments.Add(argument);
                     break;
-                case Command command:
+                case CliCommand command:
                     Subcommands.Add(command);
                     break;
                 default:
@@ -196,7 +196,7 @@ public void Add(Symbol symbol)
         /// <summary>
         /// Represents all of the symbols for the command.
         /// </summary>
-        public IEnumerator<Symbol> GetEnumerator() => Children.GetEnumerator();
+        public IEnumerator<CliSymbol> GetEnumerator() => Children.GetEnumerator();
 
         /// <inheritdoc />
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
@@ -264,7 +264,7 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
                 ParentNode? parent = FirstParent;
                 while (parent is not null)
                 {
-                    Command parentCommand = (Command)parent.Symbol;
+                    CliCommand parentCommand = (CliCommand)parent.Symbol;
 
                     if (context.IsEmpty || context.ParseResult.FindResultFor(parentCommand) is not null)
                     {
@@ -274,7 +274,7 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
                             {
                                 var option = parentCommand.Options[i];
 
-                                if (option.AppliesToSelfAndChildren)
+                                if (option.Recursive)
                                 {
                                     AddCompletionsFor(option, option._aliases);
                                 }
@@ -293,9 +293,9 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
                    .OrderBy(item => item.SortText.IndexOfCaseInsensitive(context.WordToComplete))
                    .ThenBy(symbol => symbol.Label, StringComparer.OrdinalIgnoreCase);
 
-            void AddCompletionsFor(Symbol identifier, AliasSet? aliases)
+            void AddCompletionsFor(CliSymbol identifier, AliasSet? aliases)
             {
-                if (!identifier.IsHidden)
+                if (!identifier.Hidden)
                 {
                     if (identifier.Name.ContainsCaseInsensitive(textToMatch))
                     {
diff --git a/src/System.CommandLine/Directive.cs b/src/System.CommandLine/CliDirective.cs
similarity index 94%
rename from src/System.CommandLine/Directive.cs
rename to src/System.CommandLine/CliDirective.cs
index 55e414febf..01072c0e2e 100644
--- a/src/System.CommandLine/Directive.cs
+++ b/src/System.CommandLine/CliDirective.cs
@@ -12,13 +12,13 @@ namespace System.CommandLine
     /// * It's enclosed in square brackets.
     /// * It doesn't contain spaces.
     /// </summary>
-    public class Directive : Symbol
+    public class CliDirective : CliSymbol
     {
         /// <summary>
         /// Initializes a new instance of the Directive class.
         /// </summary>
         /// <param name="name">The name of the directive. It can't contain whitespaces.</param>
-        public Directive(string name)
+        public CliDirective(string name)
             : base(name)
         {
         }
diff --git a/src/System.CommandLine/Option.cs b/src/System.CommandLine/CliOption.cs
similarity index 84%
rename from src/System.CommandLine/Option.cs
rename to src/System.CommandLine/CliOption.cs
index ac54346f49..00151f2ff4 100644
--- a/src/System.CommandLine/Option.cs
+++ b/src/System.CommandLine/CliOption.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
-using System.CommandLine.Binding;
 using System.CommandLine.Completions;
 using System.CommandLine.Parsing;
 using System.Linq;
@@ -12,18 +11,18 @@ namespace System.CommandLine
     /// <summary>
     /// A symbol defining a named parameter and a value for that parameter. 
     /// </summary>
-    public abstract class Option : Symbol
+    public abstract class CliOption : CliSymbol
     {
         internal AliasSet? _aliases;
         private List<Action<OptionResult>>? _validators;
 
-        private protected Option(string name) : base(name)
+        private protected CliOption(string name) : base(name)
         {
         }
 
-        private protected Option(string name, string[] aliases) : base(name)
+        private protected CliOption(string name, string[] aliases) : base(name)
         {
-            if (aliases != null && aliases.Length > 0) 
+            if (aliases is { Length: > 0 }) 
             {
                 _aliases = new(aliases);
             }
@@ -32,7 +31,7 @@ private protected Option(string name, string[] aliases) : base(name)
         /// <summary>
         /// Gets the <see cref="Argument">argument</see> for the option.
         /// </summary>
-        internal abstract Argument Argument { get; }
+        internal abstract CliArgument Argument { get; }
 
         /// <summary>
         /// Gets or sets the name of the Option when displayed in help.
@@ -57,16 +56,20 @@ public ArgumentArity Arity
         }
 
         /// <summary>
-        /// When set to true, this option will be applied to the command and recursively to subcommands.
-        /// It will not apply to parent commands.
+        /// When set to true, this option will be applied to its immediate parent command or commands and recursively to their subcommands.
         /// </summary>
-        public bool AppliesToSelfAndChildren { get; set; }
+        public bool Recursive { get; set; }
 
         /// <summary>
         /// Validators that will be called when the option is matched by the parser.
         /// </summary>
         public List<Action<OptionResult>> Validators => _validators ??= new();
 
+        /// <summary>
+        /// Gets or sets the <see cref="Type" /> that the option's parsed tokens will be converted to.
+        /// </summary>
+        public abstract Type ValueType { get; }
+
         internal bool HasValidators => _validators is not null && _validators.Count > 0;
 
         /// <summary>
@@ -89,19 +92,19 @@ public ArgumentArity Arity
         /// </example>
         public bool AllowMultipleArgumentsPerToken { get; set; }
 
-        internal virtual bool IsGreedy
+        internal virtual bool Greedy
             => Argument.Arity.MinimumNumberOfValues > 0 && Argument.ValueType != typeof(bool);
 
         /// <summary>
         /// Indicates whether the option is required when its parent command is invoked.
         /// </summary>
         /// <remarks>When an option is required and its parent command is invoked without it, an error results.</remarks>
-        public bool IsRequired { get; set; }
+        public bool Required { get; set; }
 
         /// <summary>
         /// Gets the unique set of strings that can be used on the command line to specify the Option.
         /// </summary>
-        /// <remarks>The collection does not contain the <see cref="Symbol.Name"/> of the Option.</remarks>
+        /// <remarks>The collection does not contain the <see cref="CliSymbol.Name"/> of the Option.</remarks>
         public ICollection<string> Aliases => _aliases ??= new();
 
         /// <summary>
diff --git a/src/System.CommandLine/RootCommand.cs b/src/System.CommandLine/CliRootCommand.cs
similarity index 90%
rename from src/System.CommandLine/RootCommand.cs
rename to src/System.CommandLine/CliRootCommand.cs
index 1d191513f4..6b4d638e16 100644
--- a/src/System.CommandLine/RootCommand.cs
+++ b/src/System.CommandLine/CliRootCommand.cs
@@ -13,9 +13,9 @@ namespace System.CommandLine
     /// <remarks>
     /// Use the RootCommand object without any subcommands for applications that perform one action. Add subcommands 
     /// to the root for applications that require actions identified by specific strings. For example, `dir` does not 
-    /// use any subcommands. See <see cref="Command"/> for applications with multiple actions.
+    /// use any subcommands. See <see cref="CliCommand"/> for applications with multiple actions.
     /// </remarks>
-    public class RootCommand : Command
+    public class CliRootCommand : CliCommand
     {
         private static Assembly? _assembly;
         private static string? _executablePath;
@@ -23,7 +23,7 @@ public class RootCommand : Command
         private static string? _executableVersion;
 
         /// <param name="description">The description of the command, shown in help.</param>
-        public RootCommand(string description = "") : base(ExecutableName, description)
+        public CliRootCommand(string description = "") : base(ExecutableName, description)
         {
             Options.Add(new HelpOption());
             Options.Add(new VersionOption());
diff --git a/src/System.CommandLine/Symbol.cs b/src/System.CommandLine/CliSymbol.cs
similarity index 92%
rename from src/System.CommandLine/Symbol.cs
rename to src/System.CommandLine/CliSymbol.cs
index 0f499d00dc..b3f724a191 100644
--- a/src/System.CommandLine/Symbol.cs
+++ b/src/System.CommandLine/CliSymbol.cs
@@ -10,11 +10,11 @@ namespace System.CommandLine
     /// <summary>
     /// Defines a named symbol that resides in a hierarchy with parent and child symbols.
     /// </summary>
-    public abstract class Symbol
+    public abstract class CliSymbol
     {
         private ParentNode? _firstParent;
 
-        private protected Symbol(string name, bool allowWhitespace = false)
+        private protected CliSymbol(string name, bool allowWhitespace = false)
         {
             Name = ThrowIfEmptyOrWithWhitespaces(name, nameof(name), allowWhitespace);
         }
@@ -34,7 +34,7 @@ private protected Symbol(string name, bool allowWhitespace = false)
         /// </summary>
         internal ParentNode? FirstParent => _firstParent;
         
-        internal void AddParent(Symbol symbol)
+        internal void AddParent(CliSymbol symbol)
         {
             if (_firstParent == null)
             {
@@ -54,12 +54,12 @@ internal void AddParent(Symbol symbol)
         /// <summary>
         /// Gets or sets a value indicating whether the symbol is hidden.
         /// </summary>
-        public bool IsHidden { get; set; }
+        public bool Hidden { get; set; }
 
         /// <summary>
         /// Gets the parent symbols.
         /// </summary>
-        public IEnumerable<Symbol> Parents
+        public IEnumerable<CliSymbol> Parents
         {
             get
             {
diff --git a/src/System.CommandLine/CommandLineConfiguration.cs b/src/System.CommandLine/CommandLineConfiguration.cs
index 0d5c581074..5d373616a7 100644
--- a/src/System.CommandLine/CommandLineConfiguration.cs
+++ b/src/System.CommandLine/CommandLineConfiguration.cs
@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using System.Threading;
 using System.IO;
+using System.CommandLine.Completions;
 
 namespace System.CommandLine
 {
@@ -21,7 +22,7 @@ public class CommandLineConfiguration
         /// Initializes a new instance of the <see cref="CommandLineConfiguration"/> class.
         /// </summary>
         /// <param name="rootCommand">The root command for the parser.</param>
-        public CommandLineConfiguration(Command rootCommand)
+        public CommandLineConfiguration(CliCommand rootCommand)
         {
             RootCommand = rootCommand ?? throw new ArgumentNullException(nameof(rootCommand));
             Directives = new()
@@ -34,7 +35,7 @@ public CommandLineConfiguration(Command rootCommand)
         /// Gets a mutable list of the enabled directives.
         /// Currently only <see cref="SuggestDirective"/> is enabled by default.
         /// </summary>
-        public List<Directive> Directives { get; }
+        public List<CliDirective> Directives { get; }
 
         /// <summary>
         /// Enables the parser to recognize and expand POSIX-style bundled options.
@@ -92,7 +93,7 @@ public CommandLineConfiguration(Command rootCommand)
         /// <summary>
         /// Gets the root command.
         /// </summary>
-        public Command RootCommand { get; }
+        public CliCommand RootCommand { get; }
 
         /// <summary>
         /// The standard output. Used by Help and other facilities that write non-error information.
@@ -173,7 +174,7 @@ public void ThrowIfInvalid()
         {
             ThrowIfInvalid(RootCommand);
 
-            static void ThrowIfInvalid(Command command)
+            static void ThrowIfInvalid(CliCommand command)
             {
                 if (command.Parents.FlattenBreadthFirst(c => c.Parents).Any(ancestor => ancestor == command))
                 {
@@ -183,10 +184,10 @@ static void ThrowIfInvalid(Command command)
                 int count = command.Subcommands.Count + command.Options.Count;
                 for (var i = 0; i < count; i++)
                 {
-                    Symbol symbol1 = GetChild(i, command, out AliasSet? aliases1);
+                    CliSymbol symbol1 = GetChild(i, command, out AliasSet? aliases1);
                     for (var j = i + 1; j < count; j++)
                     {
-                        Symbol symbol2 = GetChild(j, command, out AliasSet? aliases2);
+                        CliSymbol symbol2 = GetChild(j, command, out AliasSet? aliases2);
 
                         if (symbol1.Name.Equals(symbol2.Name, StringComparison.Ordinal)
                             || (aliases1 is not null && aliases1.Contains(symbol2.Name)))
@@ -214,14 +215,14 @@ static void ThrowIfInvalid(Command command)
                         }
                     }
 
-                    if (symbol1 is Command childCommand)
+                    if (symbol1 is CliCommand childCommand)
                     {
                         ThrowIfInvalid(childCommand);
                     }
                 }
             }
 
-            static Symbol GetChild(int index, Command command, out AliasSet? aliases)
+            static CliSymbol GetChild(int index, CliCommand command, out AliasSet? aliases)
             {
                 if (index < command.Subcommands.Count)
                 {
diff --git a/src/System.CommandLine/SuggestDirective.cs b/src/System.CommandLine/Completions/SuggestDirective.cs
similarity index 96%
rename from src/System.CommandLine/SuggestDirective.cs
rename to src/System.CommandLine/Completions/SuggestDirective.cs
index 125aeed320..6a47097874 100644
--- a/src/System.CommandLine/SuggestDirective.cs
+++ b/src/System.CommandLine/Completions/SuggestDirective.cs
@@ -3,13 +3,13 @@
 using System.Threading.Tasks;
 using System.Threading;
 
-namespace System.CommandLine
+namespace System.CommandLine.Completions
 {
     /// <summary>
     /// Enables the use of the <c>[suggest]</c> directive which when specified in command line input short circuits normal command handling and writes a newline-delimited list of suggestions suitable for use by most shells to provide command line completions.
     /// </summary>
     /// <remarks>The <c>dotnet-suggest</c> tool requires the suggest directive to be enabled for an application to provide completions.</remarks>
-    public sealed class SuggestDirective : Directive
+    public sealed class SuggestDirective : CliDirective
     {
         private CliAction? _action;
 
diff --git a/src/System.CommandLine/EnvironmentVariablesDirective.cs b/src/System.CommandLine/EnvironmentVariablesDirective.cs
index f204a38035..b560897219 100644
--- a/src/System.CommandLine/EnvironmentVariablesDirective.cs
+++ b/src/System.CommandLine/EnvironmentVariablesDirective.cs
@@ -7,7 +7,7 @@ namespace System.CommandLine
     /// <summary>
     /// Enables the use of the <c>[env:key=value]</c> directive, allowing environment variables to be set from the command line during invocation.
     /// </summary>
-    public sealed class EnvironmentVariablesDirective : Directive
+    public sealed class EnvironmentVariablesDirective : CliDirective
     {
         private CliAction? _action;
 
diff --git a/src/System.CommandLine/Help/HelpBuilder.Default.cs b/src/System.CommandLine/Help/HelpBuilder.Default.cs
index 4fb6f4b430..05ef178e09 100644
--- a/src/System.CommandLine/Help/HelpBuilder.Default.cs
+++ b/src/System.CommandLine/Help/HelpBuilder.Default.cs
@@ -20,7 +20,7 @@ public static class Default
         /// Gets an argument's default value to be displayed in help.
         /// </summary>
         /// <param name="argument">The argument to get the default value for.</param>
-        public static string GetArgumentDefaultValue(Argument argument)
+        public static string GetArgumentDefaultValue(CliArgument argument)
         {
             if (argument.HasDefaultValue)
             {
@@ -43,12 +43,12 @@ public static string GetArgumentDefaultValue(Argument argument)
         /// <summary>
         /// Gets the description for an argument (typically used in the second column text in the arguments section).
         /// </summary>
-        public static string GetArgumentDescription(Argument argument) => argument.Description ?? string.Empty;
+        public static string GetArgumentDescription(CliArgument argument) => argument.Description ?? string.Empty;
 
         /// <summary>
         /// Gets the usage title for an argument (for example: <c>&lt;value&gt;</c>, typically used in the first column text in the arguments usage section, or within the synopsis.
         /// </summary>
-        public static string GetArgumentUsageLabel(Argument argument)
+        public static string GetArgumentUsageLabel(CliArgument argument)
         {
             // Argument.HelpName is always first choice
             if (!string.IsNullOrWhiteSpace(argument.HelpName))
@@ -70,7 +70,7 @@ public static string GetArgumentUsageLabel(Argument argument)
             }
 
             // By default Option.Name == Argument.Name, don't repeat it
-            return argument.FirstParent?.Symbol is not Option ? $"<{argument.Name}>" : "";
+            return argument.FirstParent?.Symbol is not CliOption ? $"<{argument.Name}>" : "";
         }
 
         /// <summary>
@@ -78,14 +78,14 @@ public static string GetArgumentUsageLabel(Argument argument)
         /// </summary>
         /// <param name="symbol">The symbol to get a help item for.</param>
         /// <returns>Text to display.</returns>
-        public static string GetCommandUsageLabel(Command symbol)
+        public static string GetCommandUsageLabel(CliCommand symbol)
             => GetIdentifierSymbolUsageLabel(symbol, symbol._aliases);
 
-        /// <inheritdoc cref="GetCommandUsageLabel(Command)"/>
-        public static string GetOptionUsageLabel(Option symbol)
+        /// <inheritdoc cref="GetCommandUsageLabel(CliCommand)"/>
+        public static string GetOptionUsageLabel(CliOption symbol)
             => GetIdentifierSymbolUsageLabel(symbol, symbol._aliases);
 
-        private static string GetIdentifierSymbolUsageLabel(Symbol symbol, AliasSet? aliasSet)
+        private static string GetIdentifierSymbolUsageLabel(CliSymbol symbol, AliasSet? aliasSet)
         {
             var aliases =  aliasSet is null
                 ? new [] { symbol.Name }
@@ -101,7 +101,7 @@ private static string GetIdentifierSymbolUsageLabel(Symbol symbol, AliasSet? ali
 
             foreach (var argument in symbol.Arguments())
             {
-                if (!argument.IsHidden)
+                if (!argument.Hidden)
                 {
                     var argumentFirstColumnText = GetArgumentUsageLabel(argument);
 
@@ -112,7 +112,7 @@ private static string GetIdentifierSymbolUsageLabel(Symbol symbol, AliasSet? ali
                 }
             }
 
-            if (symbol is Option { IsRequired: true })
+            if (symbol is CliOption { Required: true })
             {
                 firstColumnText += $" {LocalizationResources.HelpOptionsRequiredLabel()}";
             }
@@ -183,33 +183,33 @@ public static IEnumerable<Action<HelpContext>> GetLayout()
             {
                 // by making this logic more complex, we were able to get some nice perf wins elsewhere
                 List<TwoColumnHelpRow> options = new();
-                HashSet<Option> uniqueOptions = new();
+                HashSet<CliOption> uniqueOptions = new();
                 if (ctx.Command.HasOptions)
                 {
-                    foreach (Option option in ctx.Command.Options)
+                    foreach (CliOption option in ctx.Command.Options)
                     {
-                        if (!option.IsHidden && uniqueOptions.Add(option))
+                        if (!option.Hidden && uniqueOptions.Add(option))
                         {
                             options.Add(ctx.HelpBuilder.GetTwoColumnRow(option, ctx));
                         }
                     }
                 }
 
-                Command? current = ctx.Command;
+                CliCommand? current = ctx.Command;
                 while (current is not null)
                 {
-                    Command? parentCommand = null;
+                    CliCommand? parentCommand = null;
                     ParentNode? parent = current.FirstParent;
                     while (parent is not null)
                     {
-                        if ((parentCommand = parent.Symbol as Command) is not null)
+                        if ((parentCommand = parent.Symbol as CliCommand) is not null)
                         {
                             if (parentCommand.HasOptions)
                             {
                                 foreach (var option in parentCommand.Options)
                                 {
                                     // global help aliases may be duplicated, we just ignore them
-                                    if (option.AppliesToSelfAndChildren && !option.IsHidden && uniqueOptions.Add(option))
+                                    if (option.Recursive && !option.Hidden && uniqueOptions.Add(option))
                                     {
                                         options.Add(ctx.HelpBuilder.GetTwoColumnRow(option, ctx));
                                     }
@@ -235,7 +235,7 @@ public static IEnumerable<Action<HelpContext>> GetLayout()
             };
 
         ///  <summary>
-        /// Writes a help section describing a command's additional arguments, typically shown only when <see cref="Command.TreatUnmatchedTokensAsErrors"/> is set to <see langword="true"/>.
+        /// Writes a help section describing a command's additional arguments, typically shown only when <see cref="CliCommand.TreatUnmatchedTokensAsErrors"/> is set to <see langword="true"/>.
         ///  </summary>
         public static Action<HelpContext> AdditionalArgumentsSection() =>
             ctx => ctx.HelpBuilder.WriteAdditionalArguments(ctx);
diff --git a/src/System.CommandLine/Help/HelpBuilder.cs b/src/System.CommandLine/Help/HelpBuilder.cs
index 8f6e4794d4..575222df90 100644
--- a/src/System.CommandLine/Help/HelpBuilder.cs
+++ b/src/System.CommandLine/Help/HelpBuilder.cs
@@ -15,7 +15,7 @@ public partial class HelpBuilder
     {
         private const string Indent = "  ";
 
-        private Dictionary<Symbol, Customization>? _customizationsBySymbol;
+        private Dictionary<CliSymbol, Customization>? _customizationsBySymbol;
         private Func<HelpContext, IEnumerable<Action<HelpContext>>>? _getLayout;
 
         /// <param name="maxWidth">The maximum width in characters after which help output is wrapped.</param>
@@ -43,7 +43,7 @@ public virtual void Write(HelpContext context)
                 throw new ArgumentNullException(nameof(context));
             }
 
-            if (context.Command.IsHidden)
+            if (context.Command.Hidden)
             {
                 return;
             }
@@ -75,7 +75,7 @@ public virtual void Write(HelpContext context)
         /// <param name="firstColumnText">A delegate to display the first help column (typically name and usage information).</param>
         /// <param name="secondColumnText">A delegate to display second help column (typically the description).</param>
         /// <param name="defaultValue">A delegate to display the default value for the symbol.</param>
-        public void CustomizeSymbol(Symbol symbol,
+        public void CustomizeSymbol(CliSymbol symbol,
             Func<HelpContext, string?>? firstColumnText = null,
             Func<HelpContext, string?>? secondColumnText = null,
             Func<HelpContext, string?>? defaultValue = null)
@@ -99,7 +99,7 @@ public void CustomizeLayout(Func<HelpContext, IEnumerable<Action<HelpContext>>>
             _getLayout = getLayout ?? throw new ArgumentNullException(nameof(getLayout));
         }
 
-        private string GetUsage(Command command)
+        private string GetUsage(CliCommand command)
         {
             return string.Join(" ", GetUsageParts().Where(x => !string.IsNullOrWhiteSpace(x)));
 
@@ -107,16 +107,16 @@ IEnumerable<string> GetUsageParts()
             {
                 bool displayOptionTitle = false;
 
-                IEnumerable<Command> parentCommands =
+                IEnumerable<CliCommand> parentCommands =
                     command
-                        .RecurseWhileNotNull(c => c.Parents.OfType<Command>().FirstOrDefault())
+                        .RecurseWhileNotNull(c => c.Parents.OfType<CliCommand>().FirstOrDefault())
                         .Reverse();
 
                 foreach (var parentCommand in parentCommands)
                 {
                     if (!displayOptionTitle)
                     {
-                        displayOptionTitle = parentCommand.HasOptions && parentCommand.Options.Any(x => x.AppliesToSelfAndChildren && !x.IsHidden);
+                        displayOptionTitle = parentCommand.HasOptions && parentCommand.Options.Any(x => x.Recursive && !x.Hidden);
                     }
 
                     yield return parentCommand.Name;
@@ -127,14 +127,14 @@ IEnumerable<string> GetUsageParts()
                     }
                 }
 
-                var hasCommandWithHelp = command.HasSubcommands && command.Subcommands.Any(x => !x.IsHidden);
+                var hasCommandWithHelp = command.HasSubcommands && command.Subcommands.Any(x => !x.Hidden);
 
                 if (hasCommandWithHelp)
                 {
                     yield return LocalizationResources.HelpUsageCommand();
                 }
 
-                displayOptionTitle = displayOptionTitle || (command.HasOptions && command.Options.Any(x => !x.IsHidden));
+                displayOptionTitle = displayOptionTitle || (command.HasOptions && command.Options.Any(x => !x.Hidden));
                 
                 if (displayOptionTitle)
                 {
@@ -148,17 +148,17 @@ IEnumerable<string> GetUsageParts()
             }
         }
 
-        private IEnumerable<TwoColumnHelpRow> GetCommandArgumentRows(Command command, HelpContext context) =>
+        private IEnumerable<TwoColumnHelpRow> GetCommandArgumentRows(CliCommand command, HelpContext context) =>
             command
-                .RecurseWhileNotNull(c => c.Parents.OfType<Command>().FirstOrDefault())
+                .RecurseWhileNotNull(c => c.Parents.OfType<CliCommand>().FirstOrDefault())
                 .Reverse()
-                .SelectMany(cmd => cmd.Arguments.Where(a => !a.IsHidden))
+                .SelectMany(cmd => cmd.Arguments.Where(a => !a.Hidden))
                 .Select(a => GetTwoColumnRow(a, context))
                 .Distinct();
 
         private void WriteSubcommands(HelpContext context)
         {
-            var subcommands = context.Command.Subcommands.Where(x => !x.IsHidden).Select(x => GetTwoColumnRow(x, context)).ToArray();
+            var subcommands = context.Command.Subcommands.Where(x => !x.Hidden).Select(x => GetTwoColumnRow(x, context)).ToArray();
 
             if (subcommands.Length <= 0)
             {
@@ -264,7 +264,7 @@ static IEnumerable<(string, string)> ZipWithEmpty(IEnumerable<string> first, IEn
             }
         }
 
-        private string FormatArgumentUsage(IList<Argument> arguments)
+        private string FormatArgumentUsage(IList<CliArgument> arguments)
         {
             var sb = new StringBuilder(arguments.Count * 100);
 
@@ -273,7 +273,7 @@ private string FormatArgumentUsage(IList<Argument> arguments)
             for (var i = 0; i < arguments.Count; i++)
             {
                 var argument = arguments[i];
-                if (argument.IsHidden)
+                if (argument.Hidden)
                 {
                     continue;
                 }
@@ -314,7 +314,7 @@ private string FormatArgumentUsage(IList<Argument> arguments)
 
             return sb.ToString();
             
-            bool IsOptional(Argument argument) =>
+            bool IsOptional(CliArgument argument) =>
                 argument.Arity.MinimumNumberOfValues == 0;
         }
 
@@ -382,7 +382,7 @@ private static IEnumerable<string> WrapText(string text, int maxWidth)
         /// <param name="symbol">The symbol to get a help item for.</param>
         /// <param name="context">The help context.</param>
         public TwoColumnHelpRow GetTwoColumnRow(
-            Symbol symbol,
+            CliSymbol symbol,
             HelpContext context)
         {
             if (symbol is null)
@@ -397,11 +397,11 @@ private static IEnumerable<string> WrapText(string text, int maxWidth)
                 _customizationsBySymbol.TryGetValue(symbol, out customization);
             }
 
-            if (symbol is Option or Command)
+            if (symbol is CliOption or CliCommand)
             {
                 return GetOptionOrCommandRow();
             }
-            else if (symbol is Argument argument)
+            else if (symbol is CliArgument argument)
             {
                 return GetCommandArgumentRow(argument);
             }
@@ -413,9 +413,9 @@ private static IEnumerable<string> WrapText(string text, int maxWidth)
             TwoColumnHelpRow GetOptionOrCommandRow()
             {
                 var firstColumnText = customization?.GetFirstColumn?.Invoke(context) 
-                    ?? (symbol is Option option
+                    ?? (symbol is CliOption option
                             ? Default.GetOptionUsageLabel(option)
-                            : Default.GetCommandUsageLabel((Command)symbol));
+                            : Default.GetCommandUsageLabel((CliCommand)symbol));
 
                 var customizedSymbolDescription = customization?.GetSecondColumn?.Invoke(context);
 
@@ -432,7 +432,7 @@ TwoColumnHelpRow GetOptionOrCommandRow()
                 return new TwoColumnHelpRow(firstColumnText, secondColumnText);
             }
 
-            TwoColumnHelpRow GetCommandArgumentRow(Argument argument)
+            TwoColumnHelpRow GetCommandArgumentRow(CliArgument argument)
             {
                 var firstColumnText =
                     customization?.GetFirstColumn?.Invoke(context) ?? Default.GetArgumentUsageLabel(argument);
@@ -450,10 +450,10 @@ TwoColumnHelpRow GetCommandArgumentRow(Argument argument)
                 return new TwoColumnHelpRow(firstColumnText, secondColumnText);
             }
 
-            string GetSymbolDefaultValue(Symbol symbol)
+            string GetSymbolDefaultValue(CliSymbol symbol)
             {
-                IList<Argument> arguments = symbol.Arguments();
-                var defaultArguments = arguments.Where(x => !x.IsHidden && x.HasDefaultValue).ToArray();
+                IList<CliArgument> arguments = symbol.Arguments();
+                var defaultArguments = arguments.Where(x => !x.Hidden && x.HasDefaultValue).ToArray();
 
                 if (defaultArguments.Length == 0) return "";
 
@@ -465,8 +465,8 @@ string GetSymbolDefaultValue(Symbol symbol)
         }
 
         private string GetArgumentDefaultValue(
-            Symbol parent,
-            Argument argument,
+            CliSymbol parent,
+            CliArgument argument,
             bool displayArgumentName,
             HelpContext context)
         {
diff --git a/src/System.CommandLine/Help/HelpBuilderExtensions.cs b/src/System.CommandLine/Help/HelpBuilderExtensions.cs
index 992119a375..e248349a26 100644
--- a/src/System.CommandLine/Help/HelpBuilderExtensions.cs
+++ b/src/System.CommandLine/Help/HelpBuilderExtensions.cs
@@ -15,7 +15,7 @@ public partial class HelpBuilder
         /// <param name="secondColumnText">A delegate to display second help column (typically the description).</param>
         /// <param name="defaultValue">The displayed default value for the symbol.</param>
         public void CustomizeSymbol(
-            Symbol symbol,
+            CliSymbol symbol,
             string? firstColumnText = null,
             string? secondColumnText = null,
             string? defaultValue = null)
@@ -26,7 +26,7 @@ public partial class HelpBuilder
         /// <summary>
         /// Writes help output for the specified command.
         /// </summary>
-        public void Write(Command command, TextWriter writer)
+        public void Write(CliCommand command, TextWriter writer)
         {
             Write(new HelpContext(this, command, writer));
         }
diff --git a/src/System.CommandLine/Help/HelpContext.cs b/src/System.CommandLine/Help/HelpContext.cs
index 20e0946418..00046ba778 100644
--- a/src/System.CommandLine/Help/HelpContext.cs
+++ b/src/System.CommandLine/Help/HelpContext.cs
@@ -16,7 +16,7 @@ public class HelpContext
         /// <param name="parseResult">The result of the current parse operation.</param>
         public HelpContext(
             HelpBuilder helpBuilder,
-            Command command,
+            CliCommand command,
             TextWriter output,
             ParseResult? parseResult = null)
         {
@@ -39,7 +39,7 @@ public class HelpContext
         /// <summary>
         /// The command for which help is being formatted.
         /// </summary>
-        public Command Command { get; }
+        public CliCommand Command { get; }
 
         /// <summary>
         /// A text writer to write output to.
diff --git a/src/System.CommandLine/Help/HelpOption.cs b/src/System.CommandLine/Help/HelpOption.cs
index 6512984ca3..c47c790c99 100644
--- a/src/System.CommandLine/Help/HelpOption.cs
+++ b/src/System.CommandLine/Help/HelpOption.cs
@@ -3,12 +3,12 @@
 
 namespace System.CommandLine.Help
 {
-    public sealed class HelpOption : Option<bool>
+    public sealed class HelpOption : CliOption<bool>
     {
         private CliAction? _action;
 
         /// <summary>
-        /// When added to a <see cref="Command"/>, it configures the application to show help when one of the following options are specified on the command line:
+        /// When added to a <see cref="CliCommand"/>, it configures the application to show help when one of the following options are specified on the command line:
         /// <code>
         ///    -h
         ///    /h
@@ -22,12 +22,12 @@ public HelpOption() : this("--help", new[] { "-h", "/h", "-?", "/?" })
         }
 
         /// <summary>
-        /// When added to a <see cref="Command"/>, it configures the application to show help when given name or one of the aliases are specified on the command line.
+        /// When added to a <see cref="CliCommand"/>, it configures the application to show help when given name or one of the aliases are specified on the command line.
         /// </summary>
         public HelpOption(string name, params string[] aliases)
-            : base(name, aliases, new Argument<bool>(name) { Arity = ArgumentArity.Zero })
+            : base(name, aliases, new CliArgument<bool>(name) { Arity = ArgumentArity.Zero })
         {
-            AppliesToSelfAndChildren = true;
+            Recursive = true;
             Description = LocalizationResources.HelpOptionDescription();
         }
 
@@ -38,7 +38,7 @@ public HelpOption(string name, params string[] aliases)
             set => _action = value ?? throw new ArgumentNullException(nameof(value));
         }
 
-        internal override bool IsGreedy => false;
+        internal override bool Greedy => false;
 
         public override bool Equals(object? obj) => obj is HelpOption;
 
diff --git a/src/System.CommandLine/Invocation/ParseErrorResult.cs b/src/System.CommandLine/Invocation/ParseErrorResultAction.cs
similarity index 100%
rename from src/System.CommandLine/Invocation/ParseErrorResult.cs
rename to src/System.CommandLine/Invocation/ParseErrorResultAction.cs
diff --git a/src/System.CommandLine/Invocation/TypoCorrection.cs b/src/System.CommandLine/Invocation/TypoCorrectionAction.cs
similarity index 95%
rename from src/System.CommandLine/Invocation/TypoCorrection.cs
rename to src/System.CommandLine/Invocation/TypoCorrectionAction.cs
index e3c1e4e0d5..8daead5693 100644
--- a/src/System.CommandLine/Invocation/TypoCorrection.cs
+++ b/src/System.CommandLine/Invocation/TypoCorrectionAction.cs
@@ -43,7 +43,7 @@ private static int ProvideSuggestions(ParseResult result)
             return 0;
         }
 
-        private static IEnumerable<string> GetPossibleTokens(Command targetSymbol, string token)
+        private static IEnumerable<string> GetPossibleTokens(CliCommand targetSymbol, string token)
         {
             if (!targetSymbol.HasOptions && !targetSymbol.HasSubcommands)
             {
@@ -52,10 +52,10 @@ private static IEnumerable<string> GetPossibleTokens(Command targetSymbol, strin
 
             IEnumerable<string> possibleMatches = targetSymbol
                 .Children
-                .Where(x => !x.IsHidden && x is Option or Command)
+                .Where(x => !x.Hidden && x is CliOption or CliCommand)
                 .Select(symbol =>
                 {
-                    AliasSet? aliasSet = symbol is Option option ? option._aliases : ((Command)symbol)._aliases; 
+                    AliasSet? aliasSet = symbol is CliOption option ? option._aliases : ((CliCommand)symbol)._aliases; 
 
                     if (aliasSet is null)
                     {
diff --git a/src/System.CommandLine/OptionValidation.cs b/src/System.CommandLine/OptionValidation.cs
index 647908ee88..939ca6344c 100644
--- a/src/System.CommandLine/OptionValidation.cs
+++ b/src/System.CommandLine/OptionValidation.cs
@@ -7,7 +7,7 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// Provides extension methods for <see cref="Option" />.
+    /// Provides extension methods for <see cref="CliOption" />.
     /// </summary>
     public static class OptionValidation
     {
@@ -16,7 +16,7 @@ public static class OptionValidation
         /// </summary>
         /// <param name="option">The option to configure.</param>
         /// <returns>The option being extended.</returns>
-        public static Option<FileInfo> AcceptExistingOnly(this Option<FileInfo> option)
+        public static CliOption<FileInfo> AcceptExistingOnly(this CliOption<FileInfo> option)
         {
             option._argument.AcceptExistingOnly();
 
@@ -28,7 +28,7 @@ public static Option<FileInfo> AcceptExistingOnly(this Option<FileInfo> option)
         /// </summary>
         /// <param name="option">The option to configure.</param>
         /// <returns>The option being extended.</returns>
-        public static Option<DirectoryInfo> AcceptExistingOnly(this Option<DirectoryInfo> option)
+        public static CliOption<DirectoryInfo> AcceptExistingOnly(this CliOption<DirectoryInfo> option)
         {
             option._argument.AcceptExistingOnly();
             return option;
@@ -39,7 +39,7 @@ public static Option<DirectoryInfo> AcceptExistingOnly(this Option<DirectoryInfo
         /// </summary>
         /// <param name="option">The option to configure.</param>
         /// <returns>The option being extended.</returns>
-        public static Option<FileSystemInfo> AcceptExistingOnly(this Option<FileSystemInfo> option)
+        public static CliOption<FileSystemInfo> AcceptExistingOnly(this CliOption<FileSystemInfo> option)
         {
             option._argument.AcceptExistingOnly();
             return option;
@@ -50,7 +50,7 @@ public static Option<FileSystemInfo> AcceptExistingOnly(this Option<FileSystemIn
         /// </summary>
         /// <param name="option">The option to configure.</param>
         /// <returns>The option being extended.</returns>
-        public static Option<T> AcceptExistingOnly<T>(this Option<T> option)
+        public static CliOption<T> AcceptExistingOnly<T>(this CliOption<T> option)
             where T : IEnumerable<FileSystemInfo>
         {
             option._argument.AcceptExistingOnly();
diff --git a/src/System.CommandLine/Option{T}.cs b/src/System.CommandLine/Option{T}.cs
index 99f3325fbd..f0bd1e26b5 100644
--- a/src/System.CommandLine/Option{T}.cs
+++ b/src/System.CommandLine/Option{T}.cs
@@ -5,50 +5,53 @@
 
 namespace System.CommandLine
 {
-    /// <inheritdoc cref="Option" />
+    /// <inheritdoc cref="CliOption" />
     /// <typeparam name="T">The <see cref="System.Type"/> that the option's arguments are expected to be parsed as.</typeparam>
-    public class Option<T> : Option
+    public class CliOption<T> : CliOption
     {
-        internal readonly Argument<T> _argument;
+        internal readonly CliArgument<T> _argument;
 
         /// <summary>
         /// Initializes a new instance of the Option class.
         /// </summary>
         /// <param name="name">The name of the option. It's used for parsing, displaying Help and creating parse errors.</param>>
         /// <param name="aliases">Optional aliases. Used for parsing, suggestions and displayed in Help.</param>
-        public Option(string name, params string[] aliases) 
-            : this(name, aliases, new Argument<T>(name))
+        public CliOption(string name, params string[] aliases) 
+            : this(name, aliases, new CliArgument<T>(name))
         {
         }
 
-        private protected Option(string name, Argument<T> argument) : base(name)
+        private protected CliOption(string name, CliArgument<T> argument) : base(name)
         {
             argument.AddParent(this);
             _argument = argument;
         }
 
-        private protected Option(string name, string[] aliases, Argument<T> argument)
+        private protected CliOption(string name, string[] aliases, CliArgument<T> argument)
             : base(name, aliases)
         {
             argument.AddParent(this);
             _argument = argument;
         }
 
-        /// <inheritdoc cref="Argument{T}.DefaultValueFactory" />
+        /// <inheritdoc cref="CliArgument{T}.DefaultValueFactory" />
         public Func<ArgumentResult, T>? DefaultValueFactory
         {
             get => _argument.DefaultValueFactory;
             set => _argument.DefaultValueFactory = value;
         }
 
-        /// <inheritdoc cref="Argument{T}.CustomParser" />
+        /// <inheritdoc cref="CliArgument{T}.CustomParser" />
         public Func<ArgumentResult, T>? CustomParser
         {
             get => _argument.CustomParser;
             set => _argument.CustomParser = value;
         }
 
-        internal sealed override Argument Argument => _argument;
+        /// <inheritdoc />
+        public override Type ValueType => typeof(T);
+
+        internal sealed override CliArgument Argument => _argument;
 
         /// <summary>
         /// Configures the option to accept only the specified values, and to suggest them as command line completions.
diff --git a/src/System.CommandLine/ParentNode.cs b/src/System.CommandLine/ParentNode.cs
index 517548bb69..7abde64425 100644
--- a/src/System.CommandLine/ParentNode.cs
+++ b/src/System.CommandLine/ParentNode.cs
@@ -5,9 +5,9 @@ namespace System.CommandLine
 {
     internal sealed class ParentNode
     {
-        internal ParentNode(Symbol symbol) => Symbol = symbol;
+        internal ParentNode(CliSymbol symbol) => Symbol = symbol;
 
-        internal Symbol Symbol { get; }
+        internal CliSymbol Symbol { get; }
 
         internal ParentNode? Next { get; set; }
     }
diff --git a/src/System.CommandLine/ParseDirective.cs b/src/System.CommandLine/ParseDiagramDirective.cs
similarity index 50%
rename from src/System.CommandLine/ParseDirective.cs
rename to src/System.CommandLine/ParseDiagramDirective.cs
index 3379f8dd2c..8b80a7f9a0 100644
--- a/src/System.CommandLine/ParseDirective.cs
+++ b/src/System.CommandLine/ParseDiagramDirective.cs
@@ -6,25 +6,27 @@ namespace System.CommandLine
     /// Enables the use of the <c>[parse]</c> directive, which when specified on the command line will short 
     /// circuit normal command handling and display a diagram explaining the parse result for the command line input.
     /// </summary>
-    public sealed class ParseDirective : Directive
+    public sealed class ParseDiagramDirective : CliDirective
     {
-        private const int DefaultErrorExitCode = 1;
         private CliAction? _action;
 
-        /// <param name="errorExitCode">If the parse result contains errors, this exit code will be used when the process exits.</param>
-        public ParseDirective(int errorExitCode = DefaultErrorExitCode) : base("parse")
+        /// <summary>
+        /// Writes a diagram of the parse result to the console.
+        /// </summary>
+        public ParseDiagramDirective() : base("parse")
         {
-            if (errorExitCode != DefaultErrorExitCode)
-            {
-                Action = new ParseDirectiveAction(errorExitCode);
-            }
         }
 
         /// <inheritdoc />
         public override CliAction? Action
         {
-            get => _action ??= new ParseDirectiveAction(DefaultErrorExitCode);
+            get => _action ??= new ParseDiagramAction(ParseErrorReturnValue);
             set => _action = value ?? throw new ArgumentNullException(nameof(value));
         }
+
+        /// <summary>
+        /// Gets or sets the return value, which can be used as an exit code, when parsing encounters an error.
+        /// </summary>
+        public int ParseErrorReturnValue { get; set; } = 1;
     }
-}
+}
\ No newline at end of file
diff --git a/src/System.CommandLine/ParseResult.cs b/src/System.CommandLine/ParseResult.cs
index d3c6b5c7d7..fb92ce02fc 100644
--- a/src/System.CommandLine/ParseResult.cs
+++ b/src/System.CommandLine/ParseResult.cs
@@ -58,7 +58,7 @@ public sealed class ParseResult
             _errors = errors is not null ? errors : Array.Empty<ParseError>();
         }
 
-        internal static ParseResult Empty() => new RootCommand().Parse(Array.Empty<string>());
+        internal static ParseResult Empty() => new CliRootCommand().Parse(Array.Empty<string>());
 
         /// <summary>
         /// A result indicating the command specified in the command line input.
@@ -111,7 +111,7 @@ public string[] UnmatchedTokens
         /// </summary>
         /// <param name="argument">The argument for which to get a value.</param>
         /// <returns>The parsed value or a configured default.</returns>
-        public T? GetValue<T>(Argument<T> argument)
+        public T? GetValue<T>(CliArgument<T> argument)
             => RootCommandResult.GetValue(argument);
 
         /// <summary>
@@ -119,7 +119,7 @@ public string[] UnmatchedTokens
         /// </summary>
         /// <param name="option">The option for which to get a value.</param>
         /// <returns>The parsed value or a configured default.</returns>
-        public T? GetValue<T>(Option<T> option)
+        public T? GetValue<T>(CliOption<T> option)
             => RootCommandResult.GetValue(option);
 
         /// <summary>
@@ -160,10 +160,10 @@ public string[] UnmatchedTokens
             {
                 ArgumentResult argumentResult => Convert(argumentResult.GetArgumentConversionResult()),
                 OptionResult optionResult => Convert(optionResult.ArgumentConversionResult),
-                _ => Argument<T>.CreateDefaultValue()
+                _ => CliArgument<T>.CreateDefaultValue()
             };
 
-            void Populate<TSymbol>(Dictionary<string, SymbolResult?> cache, IList<TSymbol> symbols) where TSymbol : Symbol
+            void Populate<TSymbol>(Dictionary<string, SymbolResult?> cache, IList<TSymbol> symbols) where TSymbol : CliSymbol
             {
                 var symbolResultTree = CommandResult.SymbolResultTree;
                 for (int i = 0; i < symbols.Count; i++)
@@ -194,14 +194,14 @@ public string[] UnmatchedTokens
         }
 
         /// <inheritdoc />
-        public override string ToString() => ParseDirectiveAction.Diagram(this).ToString();
+        public override string ToString() => ParseDiagramAction.Diagram(this).ToString();
 
         /// <summary>
         /// Gets the result, if any, for the specified argument.
         /// </summary>
         /// <param name="argument">The argument for which to find a result.</param>
         /// <returns>A result for the specified argument, or <see langword="null"/> if it was not provided and no default was configured.</returns>
-        public ArgumentResult? FindResultFor(Argument argument) =>
+        public ArgumentResult? FindResultFor(CliArgument argument) =>
             _rootCommandResult.FindResultFor(argument);
 
         /// <summary>
@@ -209,7 +209,7 @@ public string[] UnmatchedTokens
         /// </summary>
         /// <param name="command">The command for which to find a result.</param>
         /// <returns>A result for the specified command, or <see langword="null"/> if it was not provided.</returns>
-        public CommandResult? FindResultFor(Command command) =>
+        public CommandResult? FindResultFor(CliCommand command) =>
             _rootCommandResult.FindResultFor(command);
 
         /// <summary>
@@ -217,7 +217,7 @@ public string[] UnmatchedTokens
         /// </summary>
         /// <param name="option">The option for which to find a result.</param>
         /// <returns>A result for the specified option, or <see langword="null"/> if it was not provided and no default was configured.</returns>
-        public OptionResult? FindResultFor(Option option) =>
+        public OptionResult? FindResultFor(CliOption option) =>
             _rootCommandResult.FindResultFor(option);
 
         /// <summary>
@@ -225,14 +225,14 @@ public string[] UnmatchedTokens
         /// </summary>
         /// <param name="directive">The directive for which to find a result.</param>
         /// <returns>A result for the specified directive, or <see langword="null"/> if it was not provided.</returns>
-        public DirectiveResult? FindResultFor(Directive directive) => _rootCommandResult.FindResultFor(directive);
+        public DirectiveResult? FindResultFor(CliDirective directive) => _rootCommandResult.FindResultFor(directive);
 
         /// <summary>
         /// Gets the result, if any, for the specified symbol.
         /// </summary>
         /// <param name="symbol">The symbol for which to find a result.</param>
         /// <returns>A result for the specified symbol, or <see langword="null"/> if it was not provided and no default was configured.</returns>
-        public SymbolResult? FindResultFor(Symbol symbol)
+        public SymbolResult? FindResultFor(CliSymbol symbol)
             => _rootCommandResult.SymbolResultTree.TryGetValue(symbol, out SymbolResult? result) ? result : null;
 
         /// <summary>
@@ -245,7 +245,7 @@ public string[] UnmatchedTokens
         {
             SymbolResult currentSymbolResult = SymbolToComplete(position);
 
-            Symbol currentSymbol = currentSymbolResult switch
+            CliSymbol currentSymbol = currentSymbolResult switch
             {
                 ArgumentResult argumentResult => argumentResult.Argument,
                 OptionResult optionResult => optionResult.Option,
@@ -338,7 +338,7 @@ IEnumerable<SymbolResult> AllSymbolResultsForCompletion()
                 int? position,
                 OptionResult optionResult)
             {
-                if (optionResult.IsImplicit)
+                if (optionResult.Implicit)
                 {
                     return false;
                 }
diff --git a/src/System.CommandLine/Parsing/ArgumentResult.cs b/src/System.CommandLine/Parsing/ArgumentResult.cs
index 022ee2547e..5ef1856d20 100644
--- a/src/System.CommandLine/Parsing/ArgumentResult.cs
+++ b/src/System.CommandLine/Parsing/ArgumentResult.cs
@@ -15,7 +15,7 @@ public sealed class ArgumentResult : SymbolResult
         private bool _onlyTakeHasBeenCalled;
 
         internal ArgumentResult(
-            Argument argument,
+            CliArgument argument,
             SymbolResultTree symbolResultTree,
             SymbolResult? parent) : base(symbolResultTree, parent)
         {
@@ -25,11 +25,11 @@ public sealed class ArgumentResult : SymbolResult
         /// <summary>
         /// The argument to which the result applies.
         /// </summary>
-        public Argument Argument { get; }
+        public CliArgument Argument { get; }
 
-        internal bool IsArgumentLimitReached => Argument.Arity.MaximumNumberOfValues == (_tokens?.Count ?? 0);
+        internal bool ArgumentLimitReached => Argument.Arity.MaximumNumberOfValues == (_tokens?.Count ?? 0);
 
-        internal bool IsImplicit => Argument.HasDefaultValue && Tokens.Count == 0;
+        internal bool Implicit => Argument.HasDefaultValue && Tokens.Count == 0;
 
         internal ArgumentConversionResult GetArgumentConversionResult() =>
             _conversionResult ??= ValidateAndConvert(useValidators: true);
@@ -64,7 +64,7 @@ public void OnlyTake(int numberOfTokens)
 
             if (Parent is OptionResult)
             {
-                throw new NotSupportedException($"{nameof(OnlyTake)} is supported only for a {nameof(Command)}-owned {nameof(ArgumentResult)}");
+                throw new NotSupportedException($"{nameof(OnlyTake)} is supported only for a {nameof(CliCommand)}-owned {nameof(ArgumentResult)}");
             }
 
             _onlyTakeHasBeenCalled = true;
@@ -82,7 +82,7 @@ public void OnlyTake(int numberOfTokens)
 
             while (tokensToPass > 0 && nextArgumentIndex < arguments.Count)
             {
-                Argument nextArgument = parent.Command.Arguments[nextArgumentIndex];
+                CliArgument nextArgument = parent.Command.Arguments[nextArgumentIndex];
                 ArgumentResult nextArgumentResult;
 
                 if (SymbolResultTree.TryGetValue(nextArgument, out SymbolResult? symbolResult))
@@ -96,7 +96,7 @@ public void OnlyTake(int numberOfTokens)
                     SymbolResultTree.Add(nextArgument, nextArgumentResult);
                 }
 
-                while (!nextArgumentResult.IsArgumentLimitReached && tokensToPass > 0)
+                while (!nextArgumentResult.ArgumentLimitReached && tokensToPass > 0)
                 {
                     Token toPass = _tokens[numberOfTokens];
                     _tokens.RemoveAt(numberOfTokens);
diff --git a/src/System.CommandLine/Parsing/CommandResult.cs b/src/System.CommandLine/Parsing/CommandResult.cs
index f52a48b263..4316d2904e 100644
--- a/src/System.CommandLine/Parsing/CommandResult.cs
+++ b/src/System.CommandLine/Parsing/CommandResult.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
-using System.CommandLine.Help;
 using System.Linq;
 
 namespace System.CommandLine.Parsing
@@ -13,7 +12,7 @@ namespace System.CommandLine.Parsing
     public sealed class CommandResult : SymbolResult
     {
         internal CommandResult(
-            Command command,
+            CliCommand command,
             Token token,
             SymbolResultTree symbolResultTree,
             CommandResult? parent = null) :
@@ -26,7 +25,7 @@ public sealed class CommandResult : SymbolResult
         /// <summary>
         /// The command to which the result applies.
         /// </summary>
-        public Command Command { get; }
+        public CliCommand Command { get; }
 
         /// <summary>
         /// The token that was parsed to specify the command.
@@ -88,7 +87,7 @@ private void ValidateOptions(bool completeValidation)
             {
                 var option = options[i];
 
-                if (!completeValidation && !(option.AppliesToSelfAndChildren || option.Argument.HasDefaultValue || option is VersionOption))
+                if (!completeValidation && !(option.Recursive || option.Argument.HasDefaultValue || option is VersionOption))
                 {
                     continue;
                 }
@@ -98,7 +97,7 @@ private void ValidateOptions(bool completeValidation)
 
                 if (!SymbolResultTree.TryGetValue(option, out SymbolResult? symbolResult))
                 {
-                    if (option.IsRequired || option.Argument.HasDefaultValue)
+                    if (option.Required || option.Argument.HasDefaultValue)
                     {
                         optionResult = new(option, SymbolResultTree, null, this);
                         SymbolResultTree.Add(optionResult.Option, optionResult);
@@ -106,7 +105,7 @@ private void ValidateOptions(bool completeValidation)
                         argumentResult = new(optionResult.Option.Argument, SymbolResultTree, optionResult);
                         SymbolResultTree.Add(optionResult.Option.Argument, argumentResult);
 
-                        if (option.IsRequired && !option.Argument.HasDefaultValue)
+                        if (option.Required && !option.Argument.HasDefaultValue)
                         {
                             argumentResult.AddError(LocalizationResources.RequiredOptionWasNotProvided(option.Name));
                             continue;
@@ -154,7 +153,7 @@ private void ValidateArguments(bool completeValidation)
             var arguments = Command.Arguments;
             for (var i = 0; i < arguments.Count; i++)
             {
-                Argument argument = arguments[i];
+                CliArgument argument = arguments[i];
 
                 if (!completeValidation && !argument.HasDefaultValue)
                 {
diff --git a/src/System.CommandLine/Parsing/DirectiveResult.cs b/src/System.CommandLine/Parsing/DirectiveResult.cs
index 78ceeaf0d7..3db0cd769b 100644
--- a/src/System.CommandLine/Parsing/DirectiveResult.cs
+++ b/src/System.CommandLine/Parsing/DirectiveResult.cs
@@ -9,7 +9,7 @@ public sealed class DirectiveResult : SymbolResult
     {
         private List<string>? _values;
 
-        internal DirectiveResult(Directive directive, Token token, SymbolResultTree symbolResultTree)
+        internal DirectiveResult(CliDirective directive, Token token, SymbolResultTree symbolResultTree)
             : base(symbolResultTree, null) // directives don't belong to any command
         {
             Directive = directive;
@@ -25,7 +25,7 @@ internal DirectiveResult(Directive directive, Token token, SymbolResultTree symb
         /// <summary>
         /// The directive to which the result applies.
         /// </summary>
-        public Directive Directive { get; }
+        public CliDirective Directive { get; }
 
         /// <summary>
         /// The token that was parsed to specify the directive.
diff --git a/src/System.CommandLine/Parsing/OptionResult.cs b/src/System.CommandLine/Parsing/OptionResult.cs
index 7ca80e99a6..ea70abcad8 100644
--- a/src/System.CommandLine/Parsing/OptionResult.cs
+++ b/src/System.CommandLine/Parsing/OptionResult.cs
@@ -15,7 +15,7 @@ public sealed class OptionResult : SymbolResult
         private ArgumentConversionResult? _argumentConversionResult;
 
         internal OptionResult(
-            Option option,
+            CliOption option,
             SymbolResultTree symbolResultTree,
             Token? token = null,
             CommandResult? parent = null) :
@@ -28,13 +28,13 @@ public sealed class OptionResult : SymbolResult
         /// <summary>
         /// The option to which the result applies.
         /// </summary>
-        public Option Option { get; }
+        public CliOption Option { get; }
 
         /// <summary>
         /// Indicates whether the result was created implicitly and not due to the option being specified on the command line.
         /// </summary>
         /// <remarks>Implicit results commonly result from options having a default value.</remarks>
-        public bool IsImplicit => IdentifierToken is null || IdentifierToken.IsImplicit;
+        public bool Implicit => IdentifierToken is null || IdentifierToken.Implicit;
 
         /// <summary>
         /// The token that was parsed to specify the option.
@@ -54,11 +54,11 @@ public sealed class OptionResult : SymbolResult
                 .GetValueOrDefault<T>();
 
         internal bool IsArgumentLimitReached
-            => Option.Argument.Arity.MaximumNumberOfValues == (IsImplicit ? Tokens.Count - 1 : Tokens.Count);
+            => Option.Argument.Arity.MaximumNumberOfValues == (Implicit ? Tokens.Count - 1 : Tokens.Count);
 
         internal ArgumentConversionResult ArgumentConversionResult
             => _argumentConversionResult ??= FindResultFor(Option.Argument)!.GetArgumentConversionResult();
 
-        internal override bool UseDefaultValueFor(ArgumentResult argument) => IsImplicit;
+        internal override bool UseDefaultValueFor(ArgumentResult argument) => Implicit;
     }
 }
diff --git a/src/System.CommandLine/Parsing/ParseDirectiveAction.cs b/src/System.CommandLine/Parsing/ParseDiagramAction.cs
similarity index 92%
rename from src/System.CommandLine/Parsing/ParseDirectiveAction.cs
rename to src/System.CommandLine/Parsing/ParseDiagramAction.cs
index e2bcfbe087..17efac3083 100644
--- a/src/System.CommandLine/Parsing/ParseDirectiveAction.cs
+++ b/src/System.CommandLine/Parsing/ParseDiagramAction.cs
@@ -14,16 +14,16 @@ namespace System.CommandLine.Parsing
     /// Implements the <c>[parse]</c> directive action, which when specified on the command line 
     /// will short circuit normal command handling and display a diagram explaining the parse result for the command line input.
     /// </summary>
-    internal sealed class ParseDirectiveAction : CliAction
+    internal sealed class ParseDiagramAction : CliAction
     {
-        private readonly int _errorExitCode;
+        private readonly int _parseErrorReturnValue;
 
-        internal ParseDirectiveAction(int errorExitCode) => _errorExitCode = errorExitCode;
+        internal ParseDiagramAction(int parseErrorReturnValue) => _parseErrorReturnValue = parseErrorReturnValue;
 
         public override int Invoke(ParseResult parseResult)
         {
             parseResult.Configuration.Output.WriteLine(Diagram(parseResult));
-            return parseResult.Errors.Count == 0 ? 0 : _errorExitCode;
+            return parseResult.Errors.Count == 0 ? 0 : _parseErrorReturnValue;
         }
 
         public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
@@ -37,7 +37,7 @@ public override async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
 #else
             await parseResult.Configuration.Output.WriteLineAsync(diagram.ToString());
 #endif
-            return parseResult.Errors.Count == 0 ? 0 : _errorExitCode;
+            return parseResult.Errors.Count == 0 ? 0 : _parseErrorReturnValue;
         }
 
         /// <summary>
@@ -79,12 +79,12 @@ internal static StringBuilder Diagram(ParseResult parseResult)
 
             switch (symbolResult)
             {
-                case DirectiveResult directiveResult when directiveResult.Directive is not ParseDirective:
+                case DirectiveResult directiveResult when directiveResult.Directive is not ParseDiagramDirective:
                     break;
                 case ArgumentResult argumentResult:
                 {
                     var includeArgumentName =
-                        argumentResult.Argument.FirstParent!.Symbol is Command command &&
+                        argumentResult.Argument.FirstParent!.Symbol is CliCommand command &&
                         command.HasArguments && command.Arguments.Count > 1;
 
                     if (includeArgumentName)
@@ -146,7 +146,7 @@ internal static StringBuilder Diagram(ParseResult parseResult)
                 {
                     OptionResult? optionResult = symbolResult as OptionResult;
 
-                    if (optionResult is { IsImplicit: true })
+                    if (optionResult is { Implicit: true })
                     {
                         builder.Append("*");
                     }
diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
index 80c028323b..40e992ef3b 100644
--- a/src/System.CommandLine/Parsing/ParseOperation.cs
+++ b/src/System.CommandLine/Parsing/ParseOperation.cs
@@ -86,7 +86,7 @@ internal ParseResult Parse()
 
         private void ParseSubcommand()
         {
-            Command command = (Command)CurrentToken.Symbol!;
+            CliCommand command = (CliCommand)CurrentToken.Symbol!;
 
             _innermostCommandResult = new CommandResult(
                 command,
@@ -134,7 +134,7 @@ private void ParseCommandArguments(ref int currentArgumentCount, ref int current
             {
                 while (_innermostCommandResult.Command.HasArguments && currentArgumentIndex < _innermostCommandResult.Command.Arguments.Count)
                 {
-                    Argument argument = _innermostCommandResult.Command.Arguments[currentArgumentIndex];
+                    CliArgument argument = _innermostCommandResult.Command.Arguments[currentArgumentIndex];
 
                     if (currentArgumentCount < argument.Arity.MaximumNumberOfValues)
                     {
@@ -182,7 +182,7 @@ private void ParseCommandArguments(ref int currentArgumentCount, ref int current
 
         private void ParseOption()
         {
-            Option option = (Option)CurrentToken.Symbol!;
+            CliOption option = (CliOption)CurrentToken.Symbol!;
             OptionResult optionResult;
 
             if (!_symbolResultTree.TryGetValue(option, out SymbolResult? symbolResult))
@@ -294,7 +294,7 @@ void ParseDirective()
             {
                 var token = CurrentToken;
 
-                if (token.Symbol is not Directive directive)
+                if (token.Symbol is not CliDirective directive)
                 {
                     AddCurrentTokenToUnmatched();
                     return;
@@ -321,7 +321,7 @@ void ParseDirective()
 
                 _action = directive.Action;
 
-                if (directive is ParseDirective)
+                if (directive is ParseDiagramDirective)
                 {
                     _isParseRequested = true;
                 }
diff --git a/src/System.CommandLine/Parsing/Parser.cs b/src/System.CommandLine/Parsing/Parser.cs
index 39218ff4a2..46400109b3 100644
--- a/src/System.CommandLine/Parsing/Parser.cs
+++ b/src/System.CommandLine/Parsing/Parser.cs
@@ -18,7 +18,7 @@ public static class Parser
         /// <param name="args">The string array typically passed to a program's <c>Main</c> method.</param>
         /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
         /// <returns>A <see cref="ParseResult"/> providing details about the parse operation.</returns>
-        public static ParseResult Parse(Command command, IReadOnlyList<string> args, CommandLineConfiguration? configuration = null)
+        public static ParseResult Parse(CliCommand command, IReadOnlyList<string> args, CommandLineConfiguration? configuration = null)
             => Parse(command, args, null, configuration);
 
         /// <summary>
@@ -29,7 +29,7 @@ public static ParseResult Parse(Command command, IReadOnlyList<string> args, Com
         /// <param name="configuration">The configuration on which the parser's grammar and behaviors are based.</param>
         /// <remarks>The command line string input will be split into tokens as if it had been passed on the command line.</remarks>
         /// <returns>A <see cref="ParseResult"/> providing details about the parse operation.</returns>
-        public static ParseResult Parse(Command command, string commandLine, CommandLineConfiguration? configuration = null)
+        public static ParseResult Parse(CliCommand command, string commandLine, CommandLineConfiguration? configuration = null)
             => Parse(command, SplitCommandLine(commandLine).ToArray(), commandLine, configuration);
 
         /// <summary>
@@ -136,7 +136,7 @@ string CurrentToken()
         }
 
         private static ParseResult Parse(
-            Command command,
+            CliCommand command,
             IReadOnlyList<string> arguments,
             string? rawInput,
             CommandLineConfiguration? configuration)
diff --git a/src/System.CommandLine/Parsing/StringExtensions.cs b/src/System.CommandLine/Parsing/StringExtensions.cs
index 3ec10678d6..59e2d06b3d 100644
--- a/src/System.CommandLine/Parsing/StringExtensions.cs
+++ b/src/System.CommandLine/Parsing/StringExtensions.cs
@@ -101,8 +101,8 @@ internal static (string? Prefix, string Alias) SplitPrefix(this string rawAlias)
                             ? arg.Substring(1, colonIndex - 1) // [name:value]
                             : arg.Substring(1, arg.Length - 2); // [name] is a legal directive
 
-                        Directive? directive = knownTokens.TryGetValue(directiveName, out var directiveToken)
-                            ? (Directive)directiveToken.Symbol!
+                        CliDirective? directive = knownTokens.TryGetValue(directiveName, out var directiveToken)
+                            ? (CliDirective)directiveToken.Symbol!
                             : null;
 
                         tokenList.Add(Directive(arg, directive));
@@ -149,11 +149,11 @@ internal static (string? Prefix, string Alias) SplitPrefix(this string rawAlias)
                         switch (token.Type)
                         {
                             case TokenType.Option:
-                                tokenList.Add(Option(arg, (Option)token.Symbol!));
+                                tokenList.Add(Option(arg, (CliOption)token.Symbol!));
                                 break;
 
                             case TokenType.Command:
-                                Command cmd = (Command)token.Symbol!;
+                                CliCommand cmd = (CliCommand)token.Symbol!;
                                 if (cmd != currentCommand)
                                 {
                                     if (cmd != configuration.RootCommand)
@@ -177,7 +177,7 @@ internal static (string? Prefix, string Alias) SplitPrefix(this string rawAlias)
                          knownTokens.TryGetValue(first, out var subtoken) &&
                          subtoken.Type == TokenType.Option)
                 {
-                    tokenList.Add(Option(first, (Option)subtoken.Symbol!));
+                    tokenList.Add(Option(first, (CliOption)subtoken.Symbol!));
 
                     if (rest is not null)
                     {
@@ -193,17 +193,17 @@ internal static (string? Prefix, string Alias) SplitPrefix(this string rawAlias)
 
                 Token Argument(string value) => new(value, TokenType.Argument, default, i);
 
-                Token CommandArgument(string value, Command command) => new(value, TokenType.Argument, command, i);
+                Token CommandArgument(string value, CliCommand command) => new(value, TokenType.Argument, command, i);
 
-                Token OptionArgument(string value, Option option) => new(value, TokenType.Argument, option, i);
+                Token OptionArgument(string value, CliOption option) => new(value, TokenType.Argument, option, i);
 
-                Token Command(string value, Command cmd) => new(value, TokenType.Command, cmd, i);
+                Token Command(string value, CliCommand cmd) => new(value, TokenType.Command, cmd, i);
 
-                Token Option(string value, Option option) => new(value, TokenType.Option, option, i);
+                Token Option(string value, CliOption option) => new(value, TokenType.Option, option, i);
 
                 Token DoubleDash() => new("--", TokenType.DoubleDash, default, i);
 
-                Token Directive(string value, Directive? directive) => new(value, TokenType.Directive, directive, i);
+                Token Directive(string value, CliDirective? directive) => new(value, TokenType.Directive, directive, i);
             }
 
             tokens = tokenList;
@@ -247,7 +247,7 @@ bool TryUnbundle(ReadOnlySpan<char> alias, int argumentIndex)
                             }
 
                             tokenList.Add(new Token(found.Value, found.Type, found.Symbol, argumentIndex));
-                            if (i != alias.Length - 1 && ((Option)found.Symbol!).IsGreedy)
+                            if (i != alias.Length - 1 && ((CliOption)found.Symbol!).Greedy)
                             {
                                 int index = i + 1;
                                 if (alias[index] == ':' || alias[index] == '=')
@@ -264,7 +264,7 @@ bool TryUnbundle(ReadOnlySpan<char> alias, int argumentIndex)
                 return true;
             }
 
-            bool PreviousTokenIsAnOptionExpectingAnArgument(out Option? option)
+            bool PreviousTokenIsAnOptionExpectingAnArgument(out CliOption? option)
             {
                 if (tokenList.Count > 1)
                 {
@@ -272,7 +272,7 @@ bool PreviousTokenIsAnOptionExpectingAnArgument(out Option? option)
 
                     if (token.Type == TokenType.Option)
                     {
-                        if (token.Symbol is Option { IsGreedy: true } opt)
+                        if (token.Symbol is CliOption { Greedy: true } opt)
                         {
                             option = opt;
                             return true;
@@ -285,11 +285,11 @@ bool PreviousTokenIsAnOptionExpectingAnArgument(out Option? option)
             }
         }
 
-        private static bool FirstArgumentIsRootCommand(IReadOnlyList<string> args, Command rootCommand, bool inferRootCommand)
+        private static bool FirstArgumentIsRootCommand(IReadOnlyList<string> args, CliCommand rootCommand, bool inferRootCommand)
         {
             if (args.Count > 0)
             {
-                if (inferRootCommand && args[0] == RootCommand.ExecutablePath)
+                if (inferRootCommand && args[0] == CliRootCommand.ExecutablePath)
                 {
                     return true;
                 }
@@ -405,7 +405,7 @@ static IEnumerable<string> SplitLine(string line)
             }
         }
 
-        private static Dictionary<string, Token> ValidTokens(this Command command, IReadOnlyList<Directive>? directives)
+        private static Dictionary<string, Token> ValidTokens(this CliCommand command, IReadOnlyList<CliDirective>? directives)
         {
             Dictionary<string, Token> tokens = new(StringComparer.Ordinal);
 
@@ -413,7 +413,7 @@ static IEnumerable<string> SplitLine(string line)
             {
                 for (int directiveIndex = 0; directiveIndex < directives.Count; directiveIndex++)
                 {
-                    Directive directive = directives[directiveIndex];
+                    CliDirective directive = directives[directiveIndex];
                     tokens[directive.Name] = new Token(directive.Name, TokenType.Directive, directive, Token.ImplicitPosition);
                 }
             }
@@ -438,21 +438,21 @@ static IEnumerable<string> SplitLine(string line)
                 }
             }
 
-            Command? current = command;
+            CliCommand? current = command;
             while (current is not null)
             {
-                Command? parentCommand = null;
+                CliCommand? parentCommand = null;
                 ParentNode? parent = current.FirstParent;
                 while (parent is not null)
                 {
-                    if ((parentCommand = parent.Symbol as Command) is not null)
+                    if ((parentCommand = parent.Symbol as CliCommand) is not null)
                     {
                         if (parentCommand.HasOptions)
                         {
                             for (var i = 0; i < parentCommand.Options.Count; i++)
                             {
-                                Option option = parentCommand.Options[i];
-                                if (option.AppliesToSelfAndChildren)
+                                CliOption option = parentCommand.Options[i];
+                                if (option.Recursive)
                                 {
                                     AddOptionTokens(tokens, option);
                                 }
@@ -468,7 +468,7 @@ static IEnumerable<string> SplitLine(string line)
 
             return tokens;
 
-            static void AddCommandTokens(Dictionary<string, Token> tokens, Command cmd)
+            static void AddCommandTokens(Dictionary<string, Token> tokens, CliCommand cmd)
             {
                 tokens.Add(cmd.Name, new Token(cmd.Name, TokenType.Command, cmd, Token.ImplicitPosition));
 
@@ -481,7 +481,7 @@ static void AddCommandTokens(Dictionary<string, Token> tokens, Command cmd)
                 }
             }
 
-            static void AddOptionTokens(Dictionary<string, Token> tokens, Option option)
+            static void AddOptionTokens(Dictionary<string, Token> tokens, CliOption option)
             {
                 if (!tokens.ContainsKey(option.Name))
                 {
diff --git a/src/System.CommandLine/Parsing/SymbolResult.cs b/src/System.CommandLine/Parsing/SymbolResult.cs
index 99118c2b81..baceedefd2 100644
--- a/src/System.CommandLine/Parsing/SymbolResult.cs
+++ b/src/System.CommandLine/Parsing/SymbolResult.cs
@@ -43,31 +43,31 @@ private protected SymbolResult(SymbolResultTree symbolResultTree, SymbolResult?
         /// </summary>
         /// <param name="argument">The argument for which to find a result.</param>
         /// <returns>An argument result if the argument was matched by the parser or has a default value; otherwise, <c>null</c>.</returns>
-        public ArgumentResult? FindResultFor(Argument argument) => SymbolResultTree.FindResultFor(argument);
+        public ArgumentResult? FindResultFor(CliArgument argument) => SymbolResultTree.FindResultFor(argument);
 
         /// <summary>
         /// Finds a result for the specific command anywhere in the parse tree, including parent and child symbol results.
         /// </summary>
         /// <param name="command">The command for which to find a result.</param>
         /// <returns>An command result if the command was matched by the parser; otherwise, <c>null</c>.</returns>
-        public CommandResult? FindResultFor(Command command) => SymbolResultTree.FindResultFor(command);
+        public CommandResult? FindResultFor(CliCommand command) => SymbolResultTree.FindResultFor(command);
 
         /// <summary>
         /// Finds a result for the specific option anywhere in the parse tree, including parent and child symbol results.
         /// </summary>
         /// <param name="option">The option for which to find a result.</param>
         /// <returns>An option result if the option was matched by the parser or has a default value; otherwise, <c>null</c>.</returns>
-        public OptionResult? FindResultFor(Option option) => SymbolResultTree.FindResultFor(option);
+        public OptionResult? FindResultFor(CliOption option) => SymbolResultTree.FindResultFor(option);
 
         /// <summary>
         /// Finds a result for the specific directive anywhere in the parse tree.
         /// </summary>
         /// <param name="directive">The directive for which to find a result.</param>
         /// <returns>A directive result if the directive was matched by the parser, <c>null</c> otherwise.</returns>
-        public DirectiveResult? FindResultFor(Directive directive) => SymbolResultTree.FindResultFor(directive);
+        public DirectiveResult? FindResultFor(CliDirective directive) => SymbolResultTree.FindResultFor(directive);
 
-        /// <inheritdoc cref="ParseResult.GetValue{T}(Argument{T})"/>
-        public T? GetValue<T>(Argument<T> argument)
+        /// <inheritdoc cref="ParseResult.GetValue{T}(CliArgument{T})"/>
+        public T? GetValue<T>(CliArgument<T> argument)
         {
             if (FindResultFor(argument) is { } result &&
                 result.GetValueOrDefault<T>() is { } t)
@@ -75,11 +75,11 @@ private protected SymbolResult(SymbolResultTree symbolResultTree, SymbolResult?
                 return t;
             }
 
-            return Argument<T>.CreateDefaultValue();
+            return CliArgument<T>.CreateDefaultValue();
         }
 
-        /// <inheritdoc cref="ParseResult.GetValue{T}(Option{T})"/>
-        public T? GetValue<T>(Option<T> option)
+        /// <inheritdoc cref="ParseResult.GetValue{T}(CliOption{T})"/>
+        public T? GetValue<T>(CliOption<T> option)
         {
             if (FindResultFor(option) is { } result &&
                 result.GetValueOrDefault<T>() is { } t)
@@ -87,7 +87,7 @@ private protected SymbolResult(SymbolResultTree symbolResultTree, SymbolResult?
                 return t;
             }
 
-            return Argument<T>.CreateDefaultValue();
+            return CliArgument<T>.CreateDefaultValue();
         }
 
         internal virtual bool UseDefaultValueFor(ArgumentResult argumentResult) => false;
diff --git a/src/System.CommandLine/Parsing/SymbolResultTree.cs b/src/System.CommandLine/Parsing/SymbolResultTree.cs
index b8f3245233..00c3603884 100644
--- a/src/System.CommandLine/Parsing/SymbolResultTree.cs
+++ b/src/System.CommandLine/Parsing/SymbolResultTree.cs
@@ -5,7 +5,7 @@
 
 namespace System.CommandLine.Parsing
 {
-    internal sealed class SymbolResultTree : Dictionary<Symbol, SymbolResult>
+    internal sealed class SymbolResultTree : Dictionary<CliSymbol, SymbolResult>
     {
         internal List<ParseError>? Errors;
         internal List<Token>? UnmatchedTokens;
@@ -25,23 +25,23 @@ internal SymbolResultTree(List<string>? tokenizeErrors)
 
         internal int ErrorCount => Errors?.Count ?? 0;
 
-        internal ArgumentResult? FindResultFor(Argument argument)
+        internal ArgumentResult? FindResultFor(CliArgument argument)
             => TryGetValue(argument, out SymbolResult? result) ? (ArgumentResult)result : default;
 
-        internal CommandResult? FindResultFor(Command command)
+        internal CommandResult? FindResultFor(CliCommand command)
             => TryGetValue(command, out SymbolResult? result) ? (CommandResult)result : default;
 
-        internal OptionResult? FindResultFor(Option option)
+        internal OptionResult? FindResultFor(CliOption option)
             => TryGetValue(option, out SymbolResult? result) ? (OptionResult)result : default;
 
-        internal DirectiveResult? FindResultFor(Directive directive)
+        internal DirectiveResult? FindResultFor(CliDirective directive)
             => TryGetValue(directive, out SymbolResult? result) ? (DirectiveResult)result : default;
 
         internal IEnumerable<SymbolResult> GetChildren(SymbolResult parent)
         {
             if (parent is not ArgumentResult)
             {
-                foreach (KeyValuePair<Symbol, SymbolResult> pair in this)
+                foreach (KeyValuePair<CliSymbol, SymbolResult> pair in this)
                 {
                     if (ReferenceEquals(parent, pair.Value.Parent))
                     {
diff --git a/src/System.CommandLine/Parsing/Token.cs b/src/System.CommandLine/Parsing/Token.cs
index 5e195215b1..ef5eeba58e 100644
--- a/src/System.CommandLine/Parsing/Token.cs
+++ b/src/System.CommandLine/Parsing/Token.cs
@@ -13,7 +13,7 @@ public sealed class Token : IEquatable<Token>
         /// <param name="value">The string value of the token.</param>
         /// <param name="type">The type of the token.</param>
         /// <param name="symbol">The symbol represented by the token</param>
-        public Token(string? value, TokenType type, Symbol symbol)
+        public Token(string? value, TokenType type, CliSymbol symbol)
         {
             Value = value ?? "";
             Type = type;
@@ -21,7 +21,7 @@ public Token(string? value, TokenType type, Symbol symbol)
             Position = ImplicitPosition;
         }
        
-        internal Token(string? value, TokenType type, Symbol? symbol, int position)
+        internal Token(string? value, TokenType type, CliSymbol? symbol, int position)
         {
             Value = value ?? "";
             Type = type;
@@ -36,7 +36,7 @@ internal Token(string? value, TokenType type, Symbol? symbol, int position)
         /// </summary>
         public string Value { get; }
 
-        internal bool IsImplicit => Position == ImplicitPosition;
+        internal bool Implicit => Position == ImplicitPosition;
 
         /// <summary>
         /// The type of the token.
@@ -46,7 +46,7 @@ internal Token(string? value, TokenType type, Symbol? symbol, int position)
         /// <summary>
         /// The Symbol represented by the token (if any).
         /// </summary>
-        internal Symbol? Symbol { get; set; }
+        internal CliSymbol? Symbol { get; set; }
 
         /// <inheritdoc />
         public override bool Equals(object? obj) => Equals(obj as Token);
diff --git a/src/System.CommandLine/Parsing/TokenType.cs b/src/System.CommandLine/Parsing/TokenType.cs
index 0aae333afa..b0ccc047b3 100644
--- a/src/System.CommandLine/Parsing/TokenType.cs
+++ b/src/System.CommandLine/Parsing/TokenType.cs
@@ -11,19 +11,19 @@ public enum TokenType
         /// <summary>
         /// An argument token.
         /// </summary>
-        /// <see cref="Argument"/>
+        /// <see cref="CliArgument"/>
         Argument,
 
         /// <summary>
         /// A command token.
         /// </summary>
-        /// <see cref="Command"/>
+        /// <see cref="CliCommand"/>
         Command,
         
         /// <summary>
         /// An option token.
         /// </summary>
-        /// <see cref="Option"/>
+        /// <see cref="CliOption"/>
         Option,
         
         /// <summary>
@@ -34,7 +34,7 @@ public enum TokenType
         /// <summary>
         /// A directive token.
         /// </summary>
-        /// <see cref="System.CommandLine.Directive"/>
+        /// <see cref="CliDirective"/>
         Directive
     }
 }
diff --git a/src/System.CommandLine/SymbolExtensions.cs b/src/System.CommandLine/SymbolExtensions.cs
index e73f859638..d25b546e56 100644
--- a/src/System.CommandLine/SymbolExtensions.cs
+++ b/src/System.CommandLine/SymbolExtensions.cs
@@ -10,18 +10,18 @@ namespace System.CommandLine
     /// </summary>
     internal static class SymbolExtensions
     {
-        internal static IList<Argument> Arguments(this Symbol symbol)
+        internal static IList<CliArgument> Arguments(this CliSymbol symbol)
         {
             switch (symbol)
             {
-                case Option option:
+                case CliOption option:
                     return new[]
                     {
                         option.Argument
                     };
-                case Command command:
+                case CliCommand command:
                     return command.Arguments;
-                case Argument argument:
+                case CliArgument argument:
                     return new[]
                     {
                         argument
diff --git a/src/System.CommandLine/Help/VersionOption.cs b/src/System.CommandLine/VersionOption.cs
similarity index 70%
rename from src/System.CommandLine/Help/VersionOption.cs
rename to src/System.CommandLine/VersionOption.cs
index 63de9a68a1..eeb09eeb5b 100644
--- a/src/System.CommandLine/Help/VersionOption.cs
+++ b/src/System.CommandLine/VersionOption.cs
@@ -8,22 +8,22 @@
 
 namespace System.CommandLine
 {
-    public sealed class VersionOption : Option<bool>
+    public sealed class VersionOption : CliOption<bool>
     {
         private CliAction? _action;
 
         /// <summary>
-        /// When added to a <see cref="Command"/>, it enables the use of a <c>--version</c> option, which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
+        /// When added to a <see cref="CliCommand"/>, it enables the use of a <c>--version</c> option, which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
         /// </summary>
         public VersionOption() : this("--version", Array.Empty<string>())
         {
         }
 
         /// <summary>
-        /// When added to a <see cref="Command"/>, it enables the use of a provided option name and aliases, which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
+        /// When added to a <see cref="CliCommand"/>, it enables the use of a provided option name and aliases, which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
         /// </summary>
         public VersionOption(string name, params string[] aliases)
-            : base(name, aliases, new Argument<bool>("--version") { Arity = ArgumentArity.Zero })
+            : base(name, aliases, new CliArgument<bool>("--version") { Arity = ArgumentArity.Zero })
         {
             Description = LocalizationResources.VersionOptionDescription();
             AddValidators();
@@ -42,24 +42,24 @@ private void AddValidators()
             {
                 if (result.Parent is CommandResult parent &&
                     parent.Children.Where(r => !(r is OptionResult optionResult && optionResult.Option is VersionOption))
-                          .Any(IsNotImplicit))
+                          .Any(NotImplicit))
                 {
                     result.AddError(LocalizationResources.VersionOptionCannotBeCombinedWithOtherArguments(result.IdentifierToken?.Value ?? result.Option.Name));
                 }
             });
         }
 
-        private static bool IsNotImplicit(SymbolResult symbolResult)
+        private static bool NotImplicit(SymbolResult symbolResult)
         {
             return symbolResult switch
             {
-                ArgumentResult argumentResult => !argumentResult.IsImplicit,
-                OptionResult optionResult => !optionResult.IsImplicit,
+                ArgumentResult argumentResult => !argumentResult.Implicit,
+                OptionResult optionResult => !optionResult.Implicit,
                 _ => true
             };
         }
 
-        internal override bool IsGreedy => false;
+        internal override bool Greedy => false;
 
         public override bool Equals(object? obj) => obj is VersionOption;
 
@@ -69,7 +69,7 @@ private sealed class VersionOptionAction : CliAction
         {
             public override int Invoke(ParseResult parseResult)
             {
-                parseResult.Configuration.Output.WriteLine(RootCommand.ExecutableVersion);
+                parseResult.Configuration.Output.WriteLine(CliRootCommand.ExecutableVersion);
                 return 0;
             }