### Build Project using Command Line

Source: https://github.com/dotnet/command-line-api/blob/main/CONTRIBUTING.md

Instructions for compiling the .NET command-line API project using platform-specific build scripts. Ensure the .NET SDK is installed and accessible.

```cmd
> .\build.cmd
```

```bash
$ ./build.sh
```

--------------------------------

### Install dotnet-suggest Global Tool

Source: https://github.com/dotnet/command-line-api/blob/main/docs/dotnet-suggest.md

Installs the dotnet-suggest global tool, which is required to enable tab completion for command-line applications. This command should be run once on the machine where completion is desired.

```sh
dotnet tool install -g dotnet-suggest
```

--------------------------------

### Publish Artifacts with Multiple Outputs in 1ES Templates

Source: https://github.com/dotnet/command-line-api/blob/main/eng/common/template-guidance.md

This example demonstrates how to configure the 'templateContext' to use the 'Multiple outputs' feature when publishing artifacts with 1ES official pipeline templates. It shows how to gather build outputs into a specified target path within the artifact staging directory, reducing security scan overhead.

```yaml
extends:
  template: azure-pipelines/MicroBuild.1ES.Official.yml@MicroBuildTemplate
  parameters:
    stages:
    - stage: build
      jobs:
      - template: /eng/common/templates-official/jobs/jobs.yml@self
        parameters:
          # 1ES makes use of outputs to reduce security task injection overhead
          templateContext:
            outputs:
            - output: pipelineArtifact
              displayName: 'Publish logs from source'
              continueOnError: true
              condition: always()
              targetPath: $(Build.ArtifactStagingDirectory)/artifacts/log
              artifactName: Logs
          jobs:
          - job: Windows
            steps:
            - script: echo "friendly neighborhood" > artifacts/marvel/spiderman.txt
          # copy build outputs to artifact staging directory for publishing
          - task: CopyFiles@2
              displayName: Gather build output
              inputs:
                SourceFolder: '$(Build.SourcesDirectory)/artifacts/marvel'
                Contents: '**'
                TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/marvel'
```

--------------------------------

### System.CommandLine Argument Class API

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Details the `Argument` class, which represents a command-line argument. It includes properties for arity, completion sources, default values, help name, validators, and value type, along with methods for getting completions and default values.

```APIDOC
System.CommandLine.Argument : Symbol
  Properties:
    ArgumentArity Arity { get; set; }
    System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> CompletionSources { get; }
    System.Boolean HasDefaultValue { get; }
    System.String HelpName { get; set; }
    System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.ArgumentResult>> Validators { get; }
    System.Type ValueType { get; }
  Methods:
    System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
    System.Object GetDefaultValue()
    System.String ToString()
```

--------------------------------

### View Build Script Help

Source: https://github.com/dotnet/command-line-api/blob/main/CONTRIBUTING.md

Command to display available options and usage information for the project's build scripts on Windows or macOS/Linux.

```cmd
> .\build.cmd -help
```

```bash
$ ./build.sh --help
```

--------------------------------

### Run Tests using Command Line

Source: https://github.com/dotnet/command-line-api/blob/main/CONTRIBUTING.md

Instructions for building and running tests for the .NET command-line API project using platform-specific build scripts. This command executes all defined tests.

```cmd
> .\build.cmd -test
```

```bash
$ ./build.sh --test
```

--------------------------------

### Configure Bash Tab Completion

Source: https://github.com/dotnet/command-line-api/blob/main/docs/dotnet-suggest.md

Sets up tab completion for Bash. It generates a completion script using dotnet-suggest and sources it in the user's .bashrc file for persistent completion.

```sh
dotnet-suggest script bash >~/.dotnet-suggest-shim.bash
echo '. ~/.dotnet-suggest-shim.bash' >>~/.bashrc
```

--------------------------------

### System.CommandLine.Parsing.ParserConfiguration

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Configuration settings for the command line parser, such as POSIX bundling and token replacement.

```C#
public class ParserConfiguration
  // Constructor for ParserConfiguration.
  .ctor()
  public System.Boolean EnablePosixBundling { get; set; }
    // Enables or disables POSIX-style option bundling.
```

```C#
public class ParserConfiguration
  public System.CommandLine.Parsing.TryReplaceToken ResponseFileTokenReplacer { get; set; }
    // A delegate for replacing response file tokens.
```

```C#
public class ParseResult
  public ParserConfiguration Configuration { get; }
    // The parser configuration used for this result.
```

--------------------------------

### System.CommandLine.Help Namespace Classes

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Classes for generating and displaying help information for command-line applications.

```APIDOC
System.CommandLine.Help.HelpAction : System.CommandLine.Invocation.SynchronousCommandLineAction:
  MaxWidth { get; set; } : System.Int32 - Gets or sets the maximum width for help output.
  Invoke(System.CommandLine.ParseResult parseResult): Executes the help action, displaying help information.
  .ctor(): Constructor for HelpAction.

System.CommandLine.Help.HelpOption : System.CommandLine.Option:
  Action { get; set; } : System.CommandLine.Invocation.CommandLineAction - Gets or sets the action to perform when the option is invoked.
  ValueType { get; } : System.Type - Gets the type of the value associated with the option.
  .ctor(): Constructor for HelpOption.
  .ctor(System.String name, System.String[] aliases): Constructor with custom name and aliases.
```

--------------------------------

### Configure Zsh Tab Completion

Source: https://github.com/dotnet/command-line-api/blob/main/docs/dotnet-suggest.md

Sets up tab completion for Zsh. It generates a completion script using dotnet-suggest and sources it in the user's .zshrc file for persistent completion.

```sh
dotnet-suggest script zsh >~/.dotnet-suggest-shim.zsh
echo '. ~/.dotnet-suggest-shim.zsh' >>~/.zshrc
```

--------------------------------

### System.CommandLine.Completions

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Provides methods and properties related to command-line argument completions, including context retrieval and completion item generation.

```C#
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)
  // Extension method to add completion sources to a list.
```

```C#
public class Directive : Symbol
  public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
    // Gets completion items for a directive based on the provided context.
```

```C#
public abstract class Option : Symbol
  public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
    // Gets completion items for an option based on the provided context.
```

```C#
public class ParseResult
  public System.Collections.Generic.IReadOnlyList<System.Collections.Generic.IReadOnlyList<System.CommandLine.Completions.CompletionItem>> GetCompletions(System.Nullable<System.Int32> position = null)
    // Gets completion items for the command line input at a specific position.
```

```C#
public class ParseResult
  public System.CommandLine.Completions.CompletionContext GetCompletionContext()
    // Creates a completion context from the parse result.
```

--------------------------------

### System.CommandLine.Completions Namespace Classes

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Classes for managing and providing command-line completion suggestions.

```APIDOC
System.CommandLine.Completions.CompletionContext:
  Empty { get; } : CompletionContext - Gets an empty completion context.
  ParseResult { get; } : System.CommandLine.ParseResult - Gets the parse result associated with the completion context.
  WordToComplete { get; } : System.String - Gets the word currently being completed.

System.CommandLine.Completions.CompletionItem:
  Detail { get; } : System.String - Gets additional details for the completion item.
  Documentation { get; set; } : System.String - Gets or sets documentation for the completion item.
  InsertText { get; } : System.String - Gets the text to insert for the completion item.
  Kind { get; } : System.String - Gets the kind of the completion item (e.g., Value, Method).
  Label { get; } : System.String - Gets the label displayed for the completion item.
  SortText { get; } : System.String - Gets the text used for sorting completion items.
  Equals(CompletionItem other): Determines whether the specified CompletionItem is equal to the current object.
  Equals(System.Object obj): Determines whether the specified object is equal to the current object.
  GetHashCode(): Serves as the default hash function.
  ToString(): Returns a string representation of the CompletionItem.
  .ctor(System.String label, System.String kind = Value, System.String sortText = null, System.String insertText = null, System.String documentation = null, System.String detail = null): Constructor for CompletionItem.

System.CommandLine.Completions.SuggestDirective : System.CommandLine.Directive:
  Action { get; set; } : System.CommandLine.Invocation.CommandLineAction - Gets or sets the action to perform when the directive is encountered.
  .ctor(): Constructor for SuggestDirective.

System.CommandLine.Completions.TextCompletionContext : CompletionContext:
  CommandLineText { get; } : System.String - Gets the full command line text.
  CursorPosition { get; } : System.Int32 - Gets the current cursor position within the command line.
  AtCursorPosition(System.Int32 position): Creates a new TextCompletionContext at a specified cursor position.
```

--------------------------------

### Command Line Parsing Entry Point

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Provides a static method to parse a command line string into a structured representation. This is the primary entry point for command line parsing operations.

```csharp
public static System.Collections.Generic.IEnumerable<System.String> SplitCommandLine(System.String commandLine)
```

--------------------------------

### System.CommandLine.Parsing.CommandLineParser Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Provides static methods for parsing command-line arguments.

```APIDOC
System.CommandLine.Parsing.CommandLineParser:
  Parse(System.CommandLine.Command command, System.Collections.Generic.IReadOnlyList<System.String> args, System.CommandLine.ParserConfiguration configuration = null): System.CommandLine.ParseResult - Parses a list of string arguments against a command.
  Parse(System.CommandLine.Command command, System.String commandLine, System.CommandLine.ParserConfiguration configuration = null): System.CommandLine.ParseResult - Parses a single command line string against a command.
```

--------------------------------

### System.CommandLine CompletionSourceExtensions API

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Provides extension methods for managing completion sources, specifically for adding custom completion logic to arguments via delegates.

```APIDOC
System.CommandLine.CompletionSourceExtensions
  Extension Methods:
    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)
```

--------------------------------

### System.CommandLine.Option<T> and related validation

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Defines generic options and provides extension methods for validating option arguments, such as accepting only existing file system entries.

```C#
public class Option<T> : Option
  // Constructor for Option<T>.
  .ctor(System.String name, System.String[] aliases)
  public System.Type ValueType { get; }
    // The type of the option's value.
```

```C#
public class Option<T> : Option
  public Func<System.CommandLine.Parsing.ArgumentResult,T> CustomParser { get; set; }
    // A custom parser for the option's argument.
```

```C#
public class Option<T> : Option
  public Func<System.CommandLine.Parsing.ArgumentResult,T> DefaultValueFactory { get; set; }
    // A factory function to provide the default value.
```

```C#
public class Option<T> : Option
  public Option<T> AcceptLegalFileNamesOnly()
    // Configures the option to accept only legal file names.
```

```C#
public class Option<T> : Option
  public Option<T> AcceptLegalFilePathsOnly()
    // Configures the option to accept only legal file paths.
```

```C#
public class Option<T> : Option
  public Option<T> AcceptOnlyFromAmong(System.String[] values)
    // Configures the option to accept values only from a specified list.
```

```C#
public static class OptionValidation
  public static Option<System.IO.FileInfo> AcceptExistingOnly(this Option<System.IO.FileInfo> option)
    // Validates that the option's FileInfo value refers to an existing file.
```

```C#
public static class OptionValidation
  public static Option<System.IO.DirectoryInfo> AcceptExistingOnly(this Option<System.IO.DirectoryInfo> option)
    // Validates that the option's DirectoryInfo value refers to an existing directory.
```

```C#
public static class OptionValidation
  public static Option<System.IO.FileSystemInfo> AcceptExistingOnly(this Option<System.IO.FileSystemInfo> option)
    // Validates that the option's FileSystemInfo value refers to an existing file or directory.
```

```C#
public static class OptionValidation
  public static Option<T> AcceptExistingOnly<T>(this Option<T> option)
    // Generic validation for existing file system entries.
```

--------------------------------

### System.CommandLine.VersionOption Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents an option that displays the version of the application.

```APIDOC
System.CommandLine.VersionOption : Option:
  Action { get; set; } : System.CommandLine.Invocation.CommandLineAction - Gets or sets the action to perform when the option is invoked.
  ValueType { get; } : System.Type - Gets the type of the value associated with the option.
  .ctor(): Constructor for VersionOption.
  .ctor(System.String name, System.String[] aliases): Constructor with custom name and aliases.
```

--------------------------------

### System.CommandLine.Invocation.InvocationConfiguration

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Configuration settings for command line invocation, including exception handling and timeouts.

```C#
public class InvocationConfiguration
  // Constructor for InvocationConfiguration.
  .ctor()
  public System.Boolean EnableDefaultExceptionHandler { get; set; }
    // Enables or disables the default exception handler.
```

```C#
public class InvocationConfiguration
  public System.IO.TextWriter Error { get; set; }
    // Specifies the TextWriter for error output.
```

```C#
public class InvocationConfiguration
  public System.IO.TextWriter Output { get; set; }
    // Specifies the TextWriter for standard output.
```

```C#
public class InvocationConfiguration
  public System.Nullable<System.TimeSpan> ProcessTerminationTimeout { get; set; }
    // Sets the timeout for process termination.
```

```C#
public class ParseResult
  public InvocationConfiguration InvocationConfiguration { get; }
    // The invocation configuration used for parsing.
```

--------------------------------

### System.CommandLine ArgumentArity Struct API

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Defines the arity (number of values) for an argument. It provides static properties for common arity configurations like `ExactlyOne`, `ZeroOrMore`, and `ZeroOrOne`, and allows custom instantiation.

```APIDOC
System.CommandLine.ArgumentArity : System.ValueType, System.IEquatable<ArgumentArity>
  Static Properties:
    ArgumentArity ExactlyOne { get; }
    ArgumentArity OneOrMore { get; }
    ArgumentArity Zero { get; }
    ArgumentArity ZeroOrMore { get; }
    ArgumentArity ZeroOrOne { get; }
  Constructors:
    .ctor(System.Int32 minimumNumberOfValues, System.Int32 maximumNumberOfValues)
  Properties:
    System.Int32 MaximumNumberOfValues { get; }
    System.Int32 MinimumNumberOfValues { get; }
  Methods:
    System.Boolean Equals(ArgumentArity other)
    System.Boolean Equals(System.Object obj)
    System.Int32 GetHashCode()
```

--------------------------------

### System.CommandLine Command Class API

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents a command in a command-line interface. It can contain arguments, options, and subcommands, and defines an action to be executed when the command is invoked. Includes methods for adding symbols and parsing input.

```APIDOC
System.CommandLine.Command : Symbol, System.Collections.IEnumerable
  Constructors:
    .ctor(System.String name, System.String description = null)
  Properties:
    System.CommandLine.Invocation.CommandLineAction Action { get; set; }
    System.Collections.Generic.ICollection<System.String> Aliases { get; }
    System.Collections.Generic.IList<Argument> Arguments { get; }
    System.Collections.Generic.IEnumerable<Symbol> Children { get; }
    System.Collections.Generic.IList<Option> Options { get; }
    System.Collections.Generic.IList<Command> Subcommands { get; }
    System.Boolean TreatUnmatchedTokensAsErrors { get; set; }
    System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.CommandResult>> Validators { get; }
  Methods:
    System.Void Add(Argument argument)
    System.Void Add(Option option)
    System.Void Add(Command command)
    System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
    ParseResult Parse(System.Collections.Generic.IReadOnlyList<System.String> args, ParserConfiguration configuration = null)
    ParseResult Parse(System.String commandLine, ParserConfiguration configuration = null)
    System.Void SetAction(System.Action<ParseResult> action)
    System.Void SetAction(System.Func<ParseResult,System.Int32> action)
    System.Void SetAction(System.Func<ParseResult,System.Threading.CancellationToken,System.Threading.Tasks.Task> action)
    System.Void SetAction(System.Func<ParseResult,System.Threading.Tasks.Task> action)
    System.Void SetAction(System.Func<ParseResult,System.Threading.CancellationToken,System.Threading.Tasks.Task<System.Int32>> action)
```

--------------------------------

### Configure PowerShell Tab Completion

Source: https://github.com/dotnet/command-line-api/blob/main/docs/dotnet-suggest.md

Enables tab completion for PowerShell. This involves finding the PowerShell profile path and adding the contents of the dotnet-suggest-shim.ps1 script to it.

```powershell
> echo $profile
# Add the contents of [dotnet-suggest-shim.ps1] to your PowerShell profile.
```

--------------------------------

### System.CommandLine.Option Properties

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Properties of the abstract Option class, including aliases, arity, help name, and recursion.

```C#
public abstract class Option : Symbol
  public System.Collections.Generic.ICollection<System.String> Aliases { get; }
    // Gets the aliases for the option.
```

```C#
public abstract class Option : Symbol
  public System.Boolean AllowMultipleArgumentsPerToken { get; set; }
    // Indicates if multiple arguments can be associated with a single token.
```

```C#
public abstract class Option : Symbol
  public ArgumentArity Arity { get; set; }
    // Defines the number of arguments the option expects.
```

```C#
public abstract class Option : Symbol
  public System.Boolean HasDefaultValue { get; }
    // Checks if the option has a default value defined.
```

```C#
public abstract class Option : Symbol
  public System.String HelpName { get; set; }
    // Gets or sets the name displayed in help text.
```

```C#
public abstract class Option : Symbol
  public System.Boolean Recursive { get; set; }
    // Indicates if the option supports recursive parsing.
```

```C#
public abstract class Option : Symbol
  public System.Boolean Required { get; set; }
    // Indicates if the option is required.
```

```C#
public abstract class Option : Symbol
  public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.OptionResult>> Validators { get; }
    // Gets the list of validators for the option.
```

```C#
public abstract class Option : Symbol
  public System.Type ValueType { get; }
    // Gets the CLR type of the option's value.
```

```C#
public abstract class Option : Symbol
  public System.Object GetDefaultValue()
    // Retrieves the default value for the option.
```

--------------------------------

### System.CommandLine.Parsing.Token

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents a token parsed from the command line input.

```C#
public class ParseResult
  public System.Collections.Generic.IReadOnlyList<System.CommandLine.Parsing.Token> Tokens { get; }
    // The list of tokens parsed from the command line.
```

--------------------------------

### Token Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents a single token parsed from the command line string. It includes the token's value, type, and associated symbol.

```csharp
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)
    public TokenType Type { get; }
    public System.String Value { get; }
    public System.Boolean Equals(System.Object obj)
    public System.Boolean Equals(Token other)
    public System.Int32 GetHashCode()
    public System.String ToString()
}
```

--------------------------------

### System.CommandLine.Invocation Namespace Classes

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Classes related to the invocation and execution of command-line actions.

```APIDOC
System.CommandLine.Invocation.AsynchronousCommandLineAction : CommandLineAction:
  InvokeAsync(System.CommandLine.ParseResult parseResult, System.Threading.CancellationToken cancellationToken = null): Asynchronously invokes the action.

System.CommandLine.Invocation.CommandLineAction:
  Terminating { get; } : System.Boolean - Gets a value indicating whether the action terminates the application.
  set_Terminating(System.Boolean value): Sets whether the action terminates the application.

System.CommandLine.Invocation.ParseErrorAction : SynchronousCommandLineAction:
  ShowHelp { get; set; } : System.Boolean - Gets or sets a value indicating whether to show help on parse error.
  ShowTypoCorrections { get; set; } : System.Boolean - Gets or sets a value indicating whether to show typo corrections on parse error.
  Invoke(System.CommandLine.ParseResult parseResult): Executes the parse error action.
  .ctor(): Constructor for ParseErrorAction.

System.CommandLine.Invocation.SynchronousCommandLineAction : CommandLineAction:
  Invoke(System.CommandLine.ParseResult parseResult): Executes the action synchronously.
```

--------------------------------

### .NET CLI Root Command Structure

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.Tests/Help/Approvals/HelpBuilderTests.Help_layout_has_not_changed.approved.txt

Defines the primary command structure for a .NET CLI application. It includes the main command, positional arguments, and named options, specifying their types, descriptions, default values, and required status.

```APIDOC
Command: the-root-command

Usage:
  the-root-command <the-root-arg-no-description-no-default> [<the-root-arg-no-description-default> <the-root-arg-no-default> [<the-root-arg> [<the-root-arg-enum-default>]]] [options]

Arguments:
  <the-root-arg-no-description-no-default>
    Description: None provided.
    Type: string (required)

  <the-root-arg-no-description-default>
    Description: None provided.
    Default: the-root-arg-no-description-default-value
    Type: string (optional)

  <the-root-arg-no-default>
    Description: the-root-arg-no-default-description
    Type: string (required)

  <the-root-arg>
    Description: the-root-arg-description
    Default: the-root-arg-one-value
    Type: string (optional)

  <Read|ReadWrite|Write>
    Description: the-root-arg-enum-default-description
    Default: Read
    Type: enum (Read, ReadWrite, Write) (optional)

Options:
  -trna, --the-root-option-no-arg (REQUIRED)
    Description: the-root-option-no-arg-description
    Type: boolean (flag)

  -trondda, --the-root-option-no-description-default-arg
    Description: None provided.
    Default: the-root-option--no-description-default-arg-value
    Type: string (optional)

  -tronda, --the-root-option-no-default-arg <the-root-option-arg-no-default-arg> (REQUIRED)
    Description: the-root-option-no-default-description
    Type: string (required)

  -troda, --the-root-option-default-arg <the-root-option-arg>
    Description: the-root-option-default-arg-description
    Default: the-root-option-arg-value
    Type: string (optional)

  -troea, --the-root-option-enum-arg <Read|ReadWrite|Write>
    Description: the-root-option-description
    Default: Read
    Type: enum (Read, ReadWrite, Write) (optional)

  -trorea, --the-root-option-required-enum-arg <Read|ReadWrite|Write> (REQUIRED)
    Description: the-root-option-description
    Default: Read
    Type: enum (Read, ReadWrite, Write) (required)

  -tromld, --the-root-option-multi-line-description
    Description: the-root-option
      multi-line
      description
    Type: boolean (flag) (optional)
```

--------------------------------

### System.CommandLine.Symbol Base Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Abstract base class for all symbols (commands, options, arguments) in System.CommandLine, defining common properties and behaviors.

```APIDOC
System.CommandLine.Symbol:
  Description { get; set; } : System.String - Gets or sets the description of the symbol.
  Hidden { get; set; } : System.Boolean - Gets or sets a value indicating whether the symbol is hidden from help output.
  Name { get; } : System.String - Gets the name of the symbol.
  Parents { get; } : System.Collections.Generic.IEnumerable<Symbol> - Gets the parent symbols in the hierarchy.
  GetCompletions(System.CommandLine.Completions.CompletionContext context): Retrieves completion suggestions for the symbol based on the provided context.
  ToString(): Returns a string representation of the symbol.
```

--------------------------------

### System.CommandLine.Parsing.SymbolResult Methods

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Methods available on SymbolResult for retrieving parsed values and managing errors within the System.CommandLine parsing framework.

```APIDOC
System.CommandLine.Parsing.SymbolResult:
  GetResult(System.String name): Returns the SymbolResult for a given symbol name.
  GetValue<T>(Argument<T> argument): Retrieves the parsed value for a specific argument.
  GetValue<T>(Option<T> option): Retrieves the parsed value for a specific option.
  GetValue<T>(System.String name): Retrieves the parsed value for a symbol by its name.
  Invoke(InvocationConfiguration configuration = null): Invokes the command-line parsing and execution with a given configuration.
  InvokeAsync(InvocationConfiguration configuration = null, System.Threading.CancellationToken cancellationToken = null): Asynchronously invokes the command-line parsing and execution.
  ToString(): Returns a string representation of the SymbolResult.
```

--------------------------------

### System.CommandLine Argument<T> Class API

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents a generic command-line argument with a specific value type `T`. It allows for custom parsing and default value factories, inheriting properties from the base `Argument` class.

```APIDOC
System.CommandLine.Argument<T> : Argument
  Constructors:
    .ctor(System.String name)
  Properties:
    Func<System.CommandLine.Parsing.ArgumentResult,T> CustomParser { get; set; }
    Func<System.CommandLine.Parsing.ArgumentResult,T> DefaultValueFactory { get; set; }
    System.Boolean HasDefaultValue { get; }
    System.Type ValueType { get; }
```

--------------------------------

### System.CommandLine.RootCommand Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents the root command in a command-line application, providing access to executable information and directives.

```APIDOC
System.CommandLine.RootCommand : Command, System.Collections.IEnumerable:
  ExecutableName { get; } : System.String - Gets the name of the executable.
  ExecutablePath { get; } : System.String - Gets the path of the executable.
  .ctor(System.String description = ): Constructor for RootCommand.
  Directives { get; } : System.Collections.Generic.IList<Directive> - Gets the list of directives associated with the command.
  Add(Directive directive): Adds a directive to the command.
```

--------------------------------

### System.CommandLine ArgumentValidation Extensions API

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Provides extension methods for `Argument<T>` to enforce validation rules, such as accepting only existing file system entries or specific values from a predefined set.

```APIDOC
System.CommandLine.ArgumentValidation
  Extension Methods:
    Argument<System.IO.FileInfo> AcceptExistingOnly(this Argument<System.IO.FileInfo> argument)
    Argument<System.IO.DirectoryInfo> AcceptExistingOnly(this Argument<System.IO.DirectoryInfo> argument)
    Argument<System.IO.FileSystemInfo> AcceptExistingOnly(this Argument<System.IO.FileSystemInfo> argument)
    Argument<T> AcceptExistingOnly<T>(this Argument<T> argument)
    Argument<T> AcceptLegalFileNamesOnly<T>(this Argument<T> argument)
    Argument<T> AcceptLegalFilePathsOnly<T>(this Argument<T> argument)
    Argument<T> AcceptOnlyFromAmong<T>(this Argument<T> argument, System.String[] values)
```

--------------------------------

### TryReplaceToken Delegate

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

A delegate type used for custom token replacement logic during command line parsing. It allows for dynamic modification of the token stream.

```csharp
public delegate TryReplaceToken : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable
{
    .ctor(System.Object object, System.IntPtr method)
    public System.IAsyncResult BeginInvoke(System.String tokenToReplace, ref System.Collections.Generic.IReadOnlyList<System.String> replacementTokens, ref System.String& errorMessage, System.AsyncCallback callback, System.Object object)
    public System.Boolean EndInvoke(ref System.Collections.Generic.IReadOnlyList<System.String> replacementTokens, ref System.String& errorMessage, System.IAsyncResult result)
    public System.Boolean Invoke(System.String tokenToReplace, ref System.Collections.Generic.IReadOnlyList<System.String> replacementTokens, ref System.String& errorMessage)
}
```

--------------------------------

### SymbolResult Base Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

An abstract base class for all results of parsing symbols (commands, options, arguments) from the command line. It provides access to errors, tokens, and parent results.

```csharp
public abstract class SymbolResult
{
    public System.Collections.Generic.IEnumerable<ParseError> Errors { get; }
    public SymbolResult Parent { get; }
    public System.Collections.Generic.IReadOnlyList<Token> Tokens { get; }
    public System.Void AddError(System.String errorMessage)
    public T GetRequiredValue<T>(Argument<T> argument)
    public T GetRequiredValue<T>(Option<T> option)
    public T GetRequiredValue<T>(System.String name)
    public ArgumentResult GetResult(System.CommandLine.Argument argument)
    public CommandResult GetResult(System.CommandLine.Command command)
    public OptionResult GetResult(System.CommandLine.Option option)
    public DirectiveResult GetResult(System.CommandLine.Directive directive)
    public SymbolResult GetResult(System.String name)
    public T GetValue<T>(Argument<T> argument)
    public T GetValue<T>(Option<T> option)
    public T GetValue<T>(System.String name)
}
```

--------------------------------

### System.CommandLine.Parsing.SymbolResult

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Base class for results of parsing symbols like commands, options, and arguments.

```C#
public class ParseResult
  public System.CommandLine.Parsing.CommandResult CommandResult { get; }
    // The result of parsing the root command.
```

```C#
public class ParseResult
  public System.CommandLine.Parsing.CommandResult RootCommandResult { get; }
    // The result of parsing the root command.
```

```C#
public class ParseResult
  public System.CommandLine.Parsing.SymbolResult GetResult(Symbol symbol)
    // Gets the result for a given symbol.
```

```C#
public class ParseResult
  public System.CommandLine.Parsing.CommandResult GetResult(Command command)
    // Gets the result for a specific command.
```

```C#
public class ParseResult
  public System.CommandLine.Parsing.OptionResult GetResult(Option option)
    // Gets the result for a specific option.
```

```C#
public class ParseResult
  public System.CommandLine.Parsing.DirectiveResult GetResult(Directive directive)
    // Gets the result for a specific directive.
```

--------------------------------

### System.CommandLine.Invocation.CommandLineAction

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents an action to be performed during command line invocation, typically associated with commands or options.

```C#
public class DiagramDirective : Directive
  public System.CommandLine.Invocation.CommandLineAction Action { get; set; }
    // The action associated with this directive.
```

```C#
public class Directive : Symbol
  public System.CommandLine.Invocation.CommandLineAction Action { get; set; }
    // The action associated with this directive.
```

```C#
public class EnvironmentVariablesDirective : Directive
  public System.CommandLine.Invocation.CommandLineAction Action { get; set; }
    // The action associated with this directive.
```

```C#
public abstract class Option : Symbol
  public System.CommandLine.Invocation.CommandLineAction Action { get; set; }
    // The action associated with this option.
```

```C#
public class ParseResult
  public System.CommandLine.Invocation.CommandLineAction Action { get; }
    // The command line action that was invoked.
```

--------------------------------

### TokenType Enum

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Defines the different types of tokens that can be recognized during command line parsing, such as arguments, commands, and options.

```csharp
public enum TokenType : System.Enum, System.IComparable, System.IConvertible, System.IFormattable, System.ISpanFormattable
{
    Argument=0,
    Command=1,
    Option=2,
    DoubleDash=3,
    Directive=4
}
```

--------------------------------

### OptionResult Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents the result of parsing an option (flag or named argument) in the command line. It includes details about the option and its associated values.

```csharp
public class OptionResult : SymbolResult
{
    public Token IdentifierToken { get; }
    public System.Int32 IdentifierTokenCount { get; }
    public System.Boolean Implicit { get; }
    public System.CommandLine.Option Option { get; }
    public T GetValueOrDefault<T>()
    public System.String ToString()
}
```

--------------------------------

### System.CommandLine.Parsing.Token UnmatchedTokens

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents tokens that were not matched by the command line parser.

```C#
public class ParseResult
  public System.Collections.Generic.IReadOnlyList<System.String> UnmatchedTokens { get; }
    // The list of tokens that were not matched during parsing.
```

--------------------------------

### System.CommandLine.Parsing.ParseError

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents an error encountered during command line parsing.

```C#
public class ParseResult
  public System.Collections.Generic.IReadOnlyList<System.CommandLine.Parsing.ParseError> Errors { get; }
    // The list of parsing errors.
```

--------------------------------

### System.CommandLine.ParseResult GetRequiredValue

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Methods for retrieving required argument or option values from a ParseResult.

```C#
public class ParseResult
  public T GetRequiredValue<T>(Argument<T> argument)
    // Retrieves the required value for a specific argument.
```

```C#
public class ParseResult
  public T GetRequiredValue<T>(Option<T> option)
    // Retrieves the required value for a specific option.
```

```C#
public class ParseResult
  public T GetRequiredValue<T>(System.String name)
    // Retrieves the required value for a symbol by its name.
```

--------------------------------

### System.CommandLine.Directive Classes

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Classes representing directives, which are special commands that influence parsing or behavior.

```C#
public class DiagramDirective : Directive
  // Constructor for DiagramDirective.
  .ctor()
    // Initializes a new instance of the DiagramDirective class.
```

```C#
public class EnvironmentVariablesDirective : Directive
  // Constructor for EnvironmentVariablesDirective.
  .ctor()
    // Initializes a new instance of the EnvironmentVariablesDirective class.
```

```C#
public class Directive : Symbol
  // Constructor for Directive.
  .ctor(System.String name)
    // Initializes a new instance of the Directive class with a name.
```

--------------------------------

### System.CommandLine.Parsing.ArgumentResult Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents the result of parsing an argument, including its value and any associated errors.

```APIDOC
System.CommandLine.Parsing.ArgumentResult : SymbolResult:
  Argument { get; } : System.CommandLine.Argument - Gets the argument definition.
  Implicit { get; } : System.Boolean - Gets a value indicating whether the argument was implicitly provided.
  AddError(System.String errorMessage): Adds an error message to the argument result.
  GetValueOrDefault<T>(): Retrieves the argument's value, or the default value if not provided.
  OnlyTake(System.Int32 numberOfTokens): Specifies that only a certain number of tokens should be consumed by this argument.
  ToString(): Returns a string representation of the ArgumentResult.
```

--------------------------------

### CommandResult Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents the result of parsing a command within the command line. It holds information about the command itself and its children symbols.

```csharp
public class CommandResult : SymbolResult
{
    public System.Collections.Generic.IEnumerable<SymbolResult> Children { get; }
    public System.CommandLine.Command Command { get; }
    public Token IdentifierToken { get; }
    public System.String ToString()
}
```

--------------------------------

### ParseError Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents an error encountered during command line parsing. It includes a descriptive message and the symbol result associated with the error.

```csharp
public class ParseError
{
    public System.String Message { get; }
    public SymbolResult SymbolResult { get; }
    public System.String ToString()
}
```

--------------------------------

### DirectiveResult Class

Source: https://github.com/dotnet/command-line-api/blob/main/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

Represents the result of parsing a directive in the command line. Directives are special commands that influence parsing behavior.

```csharp
public class DirectiveResult : SymbolResult
{
    public System.CommandLine.Directive Directive { get; }
    public Token Token { get; }
    public System.Collections.Generic.IReadOnlyList<System.String> Values { get; }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.