/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "r".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("r", "r", global::System.Management.Automation.CompletionResultType.ParameterValue, "r"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "d".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("d", "d", global::System.Management.Automation.CompletionResultType.ParameterValue, "d"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "w".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("w", "w", global::System.Management.Automation.CompletionResultType.ParameterValue, "w"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "l".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("l", "l", global::System.Management.Automation.CompletionResultType.ParameterValue, "l"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "a".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("a", "a", global::System.Management.Automation.CompletionResultType.ParameterValue, "a"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "c".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("c", "c", global::System.Management.Automation.CompletionResultType.ParameterValue, "c"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "u".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("u", "u", global::System.Management.Automation.CompletionResultType.ParameterValue, "u"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "p".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("p", "p", global::System.Management.Automation.CompletionResultType.ParameterValue, "p"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "None".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("None", "None", global::System.Management.Automation.CompletionResultType.ParameterValue, "None"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Replication".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Replication", "Replication", global::System.Management.Automation.CompletionResultType.ParameterValue, "Replication"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TestFailover".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TestFailover", "TestFailover", global::System.Management.Automation.CompletionResultType.ParameterValue, "TestFailover"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Configuration".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Configuration", "Configuration", global::System.Management.Automation.CompletionResultType.ParameterValue, "Configuration"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "FabricInfrastructure".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("FabricInfrastructure", "FabricInfrastructure", global::System.Management.Automation.CompletionResultType.ParameterValue, "FabricInfrastructure"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "VersionExpiry".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("VersionExpiry", "VersionExpiry", global::System.Management.Automation.CompletionResultType.ParameterValue, "VersionExpiry"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AgentAutoUpdateInfra".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("AgentAutoUpdateInfra", "AgentAutoUpdateInfra", global::System.Management.Automation.CompletionResultType.ParameterValue, "AgentAutoUpdateInfra"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AgentAutoUpdateArtifactDeleted".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("AgentAutoUpdateArtifactDeleted", "AgentAutoUpdateArtifactDeleted", global::System.Management.Automation.CompletionResultType.ParameterValue, "AgentAutoUpdateArtifactDeleted"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AgentAutoUpdateRunAsAccount".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("AgentAutoUpdateRunAsAccount", "AgentAutoUpdateRunAsAccount", global::System.Management.Automation.CompletionResultType.ParameterValue, "AgentAutoUpdateRunAsAccount"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AgentAutoUpdateRunAsAccountExpiry".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("AgentAutoUpdateRunAsAccountExpiry", "AgentAutoUpdateRunAsAccountExpiry", global::System.Management.Automation.CompletionResultType.ParameterValue, "AgentAutoUpdateRunAsAccountExpiry"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AgentAutoUpdateRunAsAccountExpired".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("AgentAutoUpdateRunAsAccountExpired", "AgentAutoUpdateRunAsAccountExpired", global::System.Management.Automation.CompletionResultType.ParameterValue, "AgentAutoUpdateRunAsAccountExpired"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unknown".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Unknown'", "Unknown", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unknown"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Pending".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Pending'", "Pending", global::System.Management.Automation.CompletionResultType.ParameterValue, "Pending"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Running".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Running'", "Running", global::System.Management.Automation.CompletionResultType.ParameterValue, "Running"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Failed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Failed'", "Failed", global::System.Management.Automation.CompletionResultType.ParameterValue, "Failed"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Succeeded".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Succeeded'", "Succeeded", global::System.Management.Automation.CompletionResultType.ParameterValue, "Succeeded"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TimedOut".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'TimedOut'", "TimedOut", global::System.Management.Automation.CompletionResultType.ParameterValue, "TimedOut"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Canceled".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Canceled'", "Canceled", global::System.Management.Automation.CompletionResultType.ParameterValue, "Canceled"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable<global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NotStarted".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'NotStarted'", "NotStarted", global::System.Management.Automation.CompletionResultType.ParameterValue, "NotStarted");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "InProgress".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'InProgress'", "InProgress", global::System.Management.Automation.CompletionResultType.ParameterValue, "InProgress");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Completed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'Completed'", "Completed", global::System.Management.Automation.CompletionResultType.ParameterValue, "Completed");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CompletedWithErrors".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'CompletedWithErrors'", "CompletedWithErrors", global::System.Management.Automation.CompletionResultType.ParameterValue, "CompletedWithErrors");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Failed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'Failed'", "Failed", global::System.Management.Automation.CompletionResultType.ParameterValue, "Failed");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NotReturned".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'NotReturned'", "NotReturned", global::System.Management.Automation.CompletionResultType.ParameterValue, "NotReturned");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "HardwareError".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'HardwareError'", "HardwareError", global::System.Management.Automation.CompletionResultType.ParameterValue, "HardwareError");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DeviceFormatted".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'DeviceFormatted'", "DeviceFormatted", global::System.Management.Automation.CompletionResultType.ParameterValue, "DeviceFormatted");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DeviceMetadataModified".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'DeviceMetadataModified'", "DeviceMetadataModified", global::System.Management.Automation.CompletionResultType.ParameterValue, "DeviceMetadataModified");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "StorageAccountNotAccessible".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'StorageAccountNotAccessible'", "StorageAccountNotAccessible", global::System.Management.Automation.CompletionResultType.ParameterValue, "StorageAccountNotAccessible");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "UnsupportedData".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("'UnsupportedData'", "UnsupportedData", global::System.Management.Automation.CompletionResultType.ParameterValue, "UnsupportedData");
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable<global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AzureDns".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("AzureDns", "AzureDns", global::System.Management.Automation.CompletionResultType.ParameterValue, "AzureDns");
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DefaultDomainRegistrarDns".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return new global::System.Management.Automation.CompletionResult("DefaultDomainRegistrarDns", "DefaultDomainRegistrarDns", global::System.Management.Automation.CompletionResultType.ParameterValue, "DefaultDomainRegistrarDns");
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NONE".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'NONE'", "NONE", global::System.Management.Automation.CompletionResultType.ParameterValue, "NONE"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Warning".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Warning'", "Warning", global::System.Management.Automation.CompletionResultType.ParameterValue, "Warning"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Error".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Error'", "Error", global::System.Management.Automation.CompletionResultType.ParameterValue, "Error"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Info".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Info'", "Info", global::System.Management.Automation.CompletionResultType.ParameterValue, "Info"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Admin".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Admin", "Admin", global::System.Management.Automation.CompletionResultType.ParameterValue, "Admin"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Ingestor".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Ingestor", "Ingestor", global::System.Management.Automation.CompletionResultType.ParameterValue, "Ingestor"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Monitor".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Monitor", "Monitor", global::System.Management.Automation.CompletionResultType.ParameterValue, "Monitor"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "User".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("User", "User", global::System.Management.Automation.CompletionResultType.ParameterValue, "User"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "UnrestrictedViewer".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("UnrestrictedViewer", "UnrestrictedViewer", global::System.Management.Automation.CompletionResultType.ParameterValue, "UnrestrictedViewer"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Viewer".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Viewer", "Viewer", global::System.Management.Automation.CompletionResultType.ParameterValue, "Viewer"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DotNet".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("DotNet", "DotNet", global::System.Management.Automation.CompletionResultType.ParameterValue, "DotNet"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Node".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Node", "Node", global::System.Management.Automation.CompletionResultType.ParameterValue, "Node"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Java".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Java", "Java", global::System.Management.Automation.CompletionResultType.ParameterValue, "Java"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "PowerShell".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("PowerShell", "PowerShell", global::System.Management.Automation.CompletionResultType.ParameterValue, "PowerShell"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Python".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Python", "Python", global::System.Management.Automation.CompletionResultType.ParameterValue, "Python"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ConfiguringProtection".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("ConfiguringProtection", "ConfiguringProtection", global::System.Management.Automation.CompletionResultType.ParameterValue, "ConfiguringProtection"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ConfiguringProtectionFailed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("ConfiguringProtectionFailed", "ConfiguringProtectionFailed", global::System.Management.Automation.CompletionResultType.ParameterValue, "ConfiguringProtectionFailed"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ProtectionConfigured".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("ProtectionConfigured", "ProtectionConfigured", global::System.Management.Automation.CompletionResultType.ParameterValue, "ProtectionConfigured"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ProtectionStopped".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("ProtectionStopped", "ProtectionStopped", global::System.Management.Automation.CompletionResultType.ParameterValue, "ProtectionStopped"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SoftDeleted".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SoftDeleted", "SoftDeleted", global::System.Management.Automation.CompletionResultType.ParameterValue, "SoftDeleted"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SoftDeleting".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SoftDeleting", "SoftDeleting", global::System.Management.Automation.CompletionResultType.ParameterValue, "SoftDeleting"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Available".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Available", "Available", global::System.Management.Automation.CompletionResultType.ParameterValue, "Available"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unavailable".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Unavailable", "Unavailable", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unavailable"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Shutdown".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Shutdown", "Shutdown", global::System.Management.Automation.CompletionResultType.ParameterValue, "Shutdown"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Disconnected".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Disconnected", "Disconnected", global::System.Management.Automation.CompletionResultType.ParameterValue, "Disconnected"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Upgrading".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Upgrading", "Upgrading", global::System.Management.Automation.CompletionResultType.ParameterValue, "Upgrading"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "UpgradeFailed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("UpgradeFailed", "UpgradeFailed", global::System.Management.Automation.CompletionResultType.ParameterValue, "UpgradeFailed"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NoHeartbeat".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("NoHeartbeat", "NoHeartbeat", global::System.Management.Automation.CompletionResultType.ParameterValue, "NoHeartbeat"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NotJoinedToDomain".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("NotJoinedToDomain", "NotJoinedToDomain", global::System.Management.Automation.CompletionResultType.ParameterValue, "NotJoinedToDomain"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DomainTrustRelationshipLost".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("DomainTrustRelationshipLost", "DomainTrustRelationshipLost", global::System.Management.Automation.CompletionResultType.ParameterValue, "DomainTrustRelationshipLost"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SxSStackListenerNotReady".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SxSStackListenerNotReady", "SxSStackListenerNotReady", global::System.Management.Automation.CompletionResultType.ParameterValue, "SxSStackListenerNotReady"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "FSLogixNotHealthy".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("FSLogixNotHealthy", "FSLogixNotHealthy", global::System.Management.Automation.CompletionResultType.ParameterValue, "FSLogixNotHealthy"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NeedsAssistance".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("NeedsAssistance", "NeedsAssistance", global::System.Management.Automation.CompletionResultType.ParameterValue, "NeedsAssistance"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Healthy".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Healthy'", "Healthy", global::System.Management.Automation.CompletionResultType.ParameterValue, "Healthy"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Warning".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Warning'", "Warning", global::System.Management.Automation.CompletionResultType.ParameterValue, "Warning"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Critical".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Critical'", "Critical", global::System.Management.Automation.CompletionResultType.ParameterValue, "Critical"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unknown".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Unknown'", "Unknown", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unknown"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "provisioning".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'provisioning'", "provisioning", global::System.Management.Automation.CompletionResultType.ParameterValue, "provisioning"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "deprovisioning".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'deprovisioning'", "deprovisioning", global::System.Management.Automation.CompletionResultType.ParameterValue, "deprovisioning"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "succeeded".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'succeeded'", "succeeded", global::System.Management.Automation.CompletionResultType.ParameterValue, "succeeded"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "failed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'failed'", "failed", global::System.Management.Automation.CompletionResultType.ParameterValue, "failed"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "networkSourceDeleted".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'networkSourceDeleted'", "networkSourceDeleted", global::System.Management.Automation.CompletionResultType.ParameterValue, "networkSourceDeleted"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Creating".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Creating'", "Creating", global::System.Management.Automation.CompletionResultType.ParameterValue, "Creating"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unavailable".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Unavailable'", "Unavailable", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unavailable"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Running".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Running'", "Running", global::System.Management.Automation.CompletionResultType.ParameterValue, "Running"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Deleting".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Deleting'", "Deleting", global::System.Management.Automation.CompletionResultType.ParameterValue, "Deleting"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Deleted".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Deleted'", "Deleted", global::System.Management.Automation.CompletionResultType.ParameterValue, "Deleted"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Stopping".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Stopping'", "Stopping", global::System.Management.Automation.CompletionResultType.ParameterValue, "Stopping"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Stopped".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Stopped'", "Stopped", global::System.Management.Automation.CompletionResultType.ParameterValue, "Stopped"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Starting".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Starting'", "Starting", global::System.Management.Automation.CompletionResultType.ParameterValue, "Starting"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Updating".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Updating'", "Updating", global::System.Management.Automation.CompletionResultType.ParameterValue, "Updating"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadSourceType".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadSourceType", "BadSourceType", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadSourceType"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadPIRSource".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadPIRSource", "BadPIRSource", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadPIRSource"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadManagedImageSource".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadManagedImageSource", "BadManagedImageSource", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadManagedImageSource"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadSharedImageVersionSource".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadSharedImageVersionSource", "BadSharedImageVersionSource", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadSharedImageVersionSource"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadCustomizerType".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadCustomizerType", "BadCustomizerType", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadCustomizerType"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "UnsupportedCustomizerType".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("UnsupportedCustomizerType", "UnsupportedCustomizerType", global::System.Management.Automation.CompletionResultType.ParameterValue, "UnsupportedCustomizerType"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NoCustomizerScript".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("NoCustomizerScript", "NoCustomizerScript", global::System.Management.Automation.CompletionResultType.ParameterValue, "NoCustomizerScript"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadDistributeType".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadDistributeType", "BadDistributeType", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadDistributeType"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BadSharedImageDistribute".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("BadSharedImageDistribute", "BadSharedImageDistribute", global::System.Management.Automation.CompletionResultType.ParameterValue, "BadSharedImageDistribute"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ServerError".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("ServerError", "ServerError", global::System.Management.Automation.CompletionResultType.ParameterValue, "ServerError"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Other".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Other", "Other", global::System.Management.Automation.CompletionResultType.ParameterValue, "Other"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "None".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("None", "None", global::System.Management.Automation.CompletionResultType.ParameterValue, "None"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TestMigrationInProgress".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TestMigrationInProgress", "TestMigrationInProgress", global::System.Management.Automation.CompletionResultType.ParameterValue, "TestMigrationInProgress"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TestMigrationSucceeded".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TestMigrationSucceeded", "TestMigrationSucceeded", global::System.Management.Automation.CompletionResultType.ParameterValue, "TestMigrationSucceeded"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TestMigrationFailed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TestMigrationFailed", "TestMigrationFailed", global::System.Management.Automation.CompletionResultType.ParameterValue, "TestMigrationFailed"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TestMigrationCleanupInProgress".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TestMigrationCleanupInProgress", "TestMigrationCleanupInProgress", global::System.Management.Automation.CompletionResultType.ParameterValue, "TestMigrationCleanupInProgress"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "WaitingForDeployment".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'WaitingForDeployment'", "WaitingForDeployment", global::System.Management.Automation.CompletionResultType.ParameterValue, "WaitingForDeployment"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Uploading".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Uploading'", "Uploading", global::System.Management.Automation.CompletionResultType.ParameterValue, "Uploading"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Deploying".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Deploying'", "Deploying", global::System.Management.Automation.CompletionResultType.ParameterValue, "Deploying"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Ready".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Ready'", "Ready", global::System.Management.Automation.CompletionResultType.ParameterValue, "Ready"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Failed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Failed'", "Failed", global::System.Management.Automation.CompletionResultType.ParameterValue, "Failed"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Deleting".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Deleting'", "Deleting", global::System.Management.Automation.CompletionResultType.ParameterValue, "Deleting"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Detached".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Detached'", "Detached", global::System.Management.Automation.CompletionResultType.ParameterValue, "Detached"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NotEnabled".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'NotEnabled'", "NotEnabled", global::System.Management.Automation.CompletionResultType.ParameterValue, "NotEnabled"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CreatingStandby".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'CreatingStandby'", "CreatingStandby", global::System.Management.Automation.CompletionResultType.ParameterValue, "CreatingStandby"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ReplicatingData".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'ReplicatingData'", "ReplicatingData", global::System.Management.Automation.CompletionResultType.ParameterValue, "ReplicatingData"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "FailingOver".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'FailingOver'", "FailingOver", global::System.Management.Automation.CompletionResultType.ParameterValue, "FailingOver"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Healthy".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Healthy'", "Healthy", global::System.Management.Automation.CompletionResultType.ParameterValue, "Healthy"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "RemovingStandby".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'RemovingStandby'", "RemovingStandby", global::System.Management.Automation.CompletionResultType.ParameterValue, "RemovingStandby"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "MySql".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'MySql'", "MySql", global::System.Management.Automation.CompletionResultType.ParameterValue, "MySql"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SQLServer".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'SQLServer'", "SQLServer", global::System.Management.Automation.CompletionResultType.ParameterValue, "SQLServer"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SQLAzure".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'SQLAzure'", "SQLAzure", global::System.Management.Automation.CompletionResultType.ParameterValue, "SQLAzure"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Custom".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Custom'", "Custom", global::System.Management.Automation.CompletionResultType.ParameterValue, "Custom"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NotificationHub".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'NotificationHub'", "NotificationHub", global::System.Management.Automation.CompletionResultType.ParameterValue, "NotificationHub"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ServiceBus".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'ServiceBus'", "ServiceBus", global::System.Management.Automation.CompletionResultType.ParameterValue, "ServiceBus"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "EventHub".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'EventHub'", "EventHub", global::System.Management.Automation.CompletionResultType.ParameterValue, "EventHub"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ApiHub".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'ApiHub'", "ApiHub", global::System.Management.Automation.CompletionResultType.ParameterValue, "ApiHub"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DocDb".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'DocDb'", "DocDb", global::System.Management.Automation.CompletionResultType.ParameterValue, "DocDb"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "RedisCache".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'RedisCache'", "RedisCache", global::System.Management.Automation.CompletionResultType.ParameterValue, "RedisCache"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "PostgreSQL".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'PostgreSQL'", "PostgreSQL", global::System.Management.Automation.CompletionResultType.ParameterValue, "PostgreSQL"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Small".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Small", "Small", global::System.Management.Automation.CompletionResultType.ParameterValue, "Small"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Medium".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Medium", "Medium", global::System.Management.Automation.CompletionResultType.ParameterValue, "Medium"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Large".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Large", "Large", global::System.Management.Automation.CompletionResultType.ParameterValue, "Large"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "D1".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("D1", "D1", global::System.Management.Automation.CompletionResultType.ParameterValue, "D1"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "D2".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("D2", "D2", global::System.Management.Automation.CompletionResultType.ParameterValue, "D2"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "D3".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("D3", "D3", global::System.Management.Automation.CompletionResultType.ParameterValue, "D3"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NestedSmall".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("NestedSmall", "NestedSmall", global::System.Management.Automation.CompletionResultType.ParameterValue, "NestedSmall"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Default".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Default", "Default", global::System.Management.Automation.CompletionResultType.ParameterValue, "Default"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "persistent".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("persistent", "persistent", global::System.Management.Automation.CompletionResultType.ParameterValue, "persistent"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "independent_persistent".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("independent_persistent", "independent_persistent", global::System.Management.Automation.CompletionResultType.ParameterValue, "independent_persistent"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "independent_nonpersistent".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("independent_nonpersistent", "independent_nonpersistent", global::System.Management.Automation.CompletionResultType.ParameterValue, "independent_nonpersistent"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "nonpersistent".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("nonpersistent", "nonpersistent", global::System.Management.Automation.CompletionResultType.ParameterValue, "nonpersistent"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "undoable".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("undoable", "undoable", global::System.Management.Automation.CompletionResultType.ParameterValue, "undoable"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "append".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("append", "append", global::System.Management.Automation.CompletionResultType.ParameterValue, "append"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Provisioning".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Provisioning", "Provisioning", global::System.Management.Automation.CompletionResultType.ParameterValue, "Provisioning"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Active".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Active", "Active", global::System.Management.Automation.CompletionResultType.ParameterValue, "Active"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Suspended".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Suspended", "Suspended", global::System.Management.Automation.CompletionResultType.ParameterValue, "Suspended"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unsubscribed".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Unsubscribed", "Unsubscribed", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unsubscribed"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "user".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'user'", "user", global::System.Management.Automation.CompletionResultType.ParameterValue, "user"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "application".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'application'", "application", global::System.Management.Automation.CompletionResultType.ParameterValue, "application"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "managedIdentity".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'managedIdentity'", "managedIdentity", global::System.Management.Automation.CompletionResultType.ParameterValue, "managedIdentity"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "key".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'key'", "key", global::System.Management.Automation.CompletionResultType.ParameterValue, "key"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Initial".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Initial'", "Initial", global::System.Management.Automation.CompletionResultType.ParameterValue, "Initial"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Enable".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Enable'", "Enable", global::System.Management.Automation.CompletionResultType.ParameterValue, "Enable"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Disable".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Disable'", "Disable", global::System.Management.Automation.CompletionResultType.ParameterValue, "Disable"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Existing".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Existing'", "Existing", global::System.Management.Automation.CompletionResultType.ParameterValue, "Existing"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unknown".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Unknown'", "Unknown", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unknown"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Submitting".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Submitting'", "Submitting", global::System.Management.Automation.CompletionResultType.ParameterValue, "Submitting"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Pending".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Pending'", "Pending", global::System.Management.Automation.CompletionResultType.ParameterValue, "Pending"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Rejected".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Rejected'", "Rejected", global::System.Management.Automation.CompletionResultType.ParameterValue, "Rejected"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TimedOut".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'TimedOut'", "TimedOut", global::System.Management.Automation.CompletionResultType.ParameterValue, "TimedOut"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "PendingRevalidation".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'PendingRevalidation'", "PendingRevalidation", global::System.Management.Automation.CompletionResultType.ParameterValue, "PendingRevalidation"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Approved".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Approved'", "Approved", global::System.Management.Automation.CompletionResultType.ParameterValue, "Approved"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "RefreshingValidationToken".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'RefreshingValidationToken'", "RefreshingValidationToken", global::System.Management.Automation.CompletionResultType.ParameterValue, "RefreshingValidationToken"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "InternalError".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'InternalError'", "InternalError", global::System.Management.Automation.CompletionResultType.ParameterValue, "InternalError"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "MULTIJSON".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("MULTIJSON", "MULTIJSON", global::System.Management.Automation.CompletionResultType.ParameterValue, "MULTIJSON"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "JSON".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("JSON", "JSON", global::System.Management.Automation.CompletionResultType.ParameterValue, "JSON"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CSV".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CSV", "CSV", global::System.Management.Automation.CompletionResultType.ParameterValue, "CSV"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TSV".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TSV", "TSV", global::System.Management.Automation.CompletionResultType.ParameterValue, "TSV"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SCSV".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SCSV", "SCSV", global::System.Management.Automation.CompletionResultType.ParameterValue, "SCSV"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SOHSV".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SOHSV", "SOHSV", global::System.Management.Automation.CompletionResultType.ParameterValue, "SOHSV"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "PSV".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("PSV", "PSV", global::System.Management.Automation.CompletionResultType.ParameterValue, "PSV"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TXT".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TXT", "TXT", global::System.Management.Automation.CompletionResultType.ParameterValue, "TXT"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "RAW".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("RAW", "RAW", global::System.Management.Automation.CompletionResultType.ParameterValue, "RAW"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SINGLEJSON".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SINGLEJSON", "SINGLEJSON", global::System.Management.Automation.CompletionResultType.ParameterValue, "SINGLEJSON"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "AVRO".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("AVRO", "AVRO", global::System.Management.Automation.CompletionResultType.ParameterValue, "AVRO"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "TSVE".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("TSVE", "TSVE", global::System.Management.Automation.CompletionResultType.ParameterValue, "TSVE"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "PARQUET".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("PARQUET", "PARQUET", global::System.Management.Automation.CompletionResultType.ParameterValue, "PARQUET"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "ORC".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("ORC", "ORC", global::System.Management.Automation.CompletionResultType.ParameterValue, "ORC"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "APACHEAVRO".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("APACHEAVRO", "APACHEAVRO", global::System.Management.Automation.CompletionResultType.ParameterValue, "APACHEAVRO"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "W3CLOGFILE".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("W3CLOGFILE", "W3CLOGFILE", global::System.Management.Automation.CompletionResultType.ParameterValue, "W3CLOGFILE"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Any".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Any'", "Any", global::System.Management.Automation.CompletionResultType.ParameterValue, "Any"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Equal".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Equal'", "Equal", global::System.Management.Automation.CompletionResultType.ParameterValue, "Equal"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Contains".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Contains'", "Contains", global::System.Management.Automation.CompletionResultType.ParameterValue, "Contains"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "BeginsWith".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'BeginsWith'", "BeginsWith", global::System.Management.Automation.CompletionResultType.ParameterValue, "BeginsWith"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "EndsWith".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'EndsWith'", "EndsWith", global::System.Management.Automation.CompletionResultType.ParameterValue, "EndsWith"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "LessThan".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'LessThan'", "LessThan", global::System.Management.Automation.CompletionResultType.ParameterValue, "LessThan"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "LessThanOrEqual".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'LessThanOrEqual'", "LessThanOrEqual", global::System.Management.Automation.CompletionResultType.ParameterValue, "LessThanOrEqual"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "GreaterThan".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'GreaterThan'", "GreaterThan", global::System.Management.Automation.CompletionResultType.ParameterValue, "GreaterThan"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "GreaterThanOrEqual".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'GreaterThanOrEqual'", "GreaterThanOrEqual", global::System.Management.Automation.CompletionResultType.ParameterValue, "GreaterThanOrEqual"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "RegEx".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'RegEx'", "RegEx", global::System.Management.Automation.CompletionResultType.ParameterValue, "RegEx"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CertificateIssued".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CertificateIssued", "CertificateIssued", global::System.Management.Automation.CompletionResultType.ParameterValue, "CertificateIssued"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CertificateOrderCanceled".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CertificateOrderCanceled", "CertificateOrderCanceled", global::System.Management.Automation.CompletionResultType.ParameterValue, "CertificateOrderCanceled"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CertificateOrderCreated".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CertificateOrderCreated", "CertificateOrderCreated", global::System.Management.Automation.CompletionResultType.ParameterValue, "CertificateOrderCreated"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CertificateRevoked".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CertificateRevoked", "CertificateRevoked", global::System.Management.Automation.CompletionResultType.ParameterValue, "CertificateRevoked"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "DomainValidationComplete".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("DomainValidationComplete", "DomainValidationComplete", global::System.Management.Automation.CompletionResultType.ParameterValue, "DomainValidationComplete"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "FraudDetected".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("FraudDetected", "FraudDetected", global::System.Management.Automation.CompletionResultType.ParameterValue, "FraudDetected"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "OrgNameChange".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("OrgNameChange", "OrgNameChange", global::System.Management.Automation.CompletionResultType.ParameterValue, "OrgNameChange"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "OrgValidationComplete".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("OrgValidationComplete", "OrgValidationComplete", global::System.Management.Automation.CompletionResultType.ParameterValue, "OrgValidationComplete"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "SanDrop".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("SanDrop", "SanDrop", global::System.Management.Automation.CompletionResultType.ParameterValue, "SanDrop"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "FraudCleared".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("FraudCleared", "FraudCleared", global::System.Management.Automation.CompletionResultType.ParameterValue, "FraudCleared"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CertificateExpired".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CertificateExpired", "CertificateExpired", global::System.Management.Automation.CompletionResultType.ParameterValue, "CertificateExpired"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "CertificateExpirationWarning".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("CertificateExpirationWarning", "CertificateExpirationWarning", global::System.Management.Automation.CompletionResultType.ParameterValue, "CertificateExpirationWarning"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "FraudDocumentationRequired".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("FraudDocumentationRequired", "FraudDocumentationRequired", global::System.Management.Automation.CompletionResultType.ParameterValue, "FraudDocumentationRequired"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Unknown".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("Unknown", "Unknown", global::System.Management.Automation.CompletionResultType.ParameterValue, "Unknown"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S72m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S72m'", "S72m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S72m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S144m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S144m'", "S144m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S144m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S72".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S72'", "S72", global::System.Management.Automation.CompletionResultType.ParameterValue, "S72"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S144".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S144'", "S144", global::System.Management.Automation.CompletionResultType.ParameterValue, "S144"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S192".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S192'", "S192", global::System.Management.Automation.CompletionResultType.ParameterValue, "S192"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S192m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S192m'", "S192m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S192m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S192xm".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S192xm'", "S192xm", global::System.Management.Automation.CompletionResultType.ParameterValue, "S192xm"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S96".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S96'", "S96", global::System.Management.Automation.CompletionResultType.ParameterValue, "S96"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S112".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S112'", "S112", global::System.Management.Automation.CompletionResultType.ParameterValue, "S112"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S224".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S224'", "S224", global::System.Management.Automation.CompletionResultType.ParameterValue, "S224"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S224m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S224m'", "S224m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S224m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S224om".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S224om'", "S224om", global::System.Management.Automation.CompletionResultType.ParameterValue, "S224om"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S224oo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S224oo'", "S224oo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S224oo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S224oom".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S224oom'", "S224oom", global::System.Management.Automation.CompletionResultType.ParameterValue, "S224oom"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S224ooo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S224ooo'", "S224ooo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S224ooo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S384".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S384'", "S384", global::System.Management.Automation.CompletionResultType.ParameterValue, "S384"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S384m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S384m'", "S384m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S384m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S384xm".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S384xm'", "S384xm", global::System.Management.Automation.CompletionResultType.ParameterValue, "S384xm"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S384xxm".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S384xxm'", "S384xxm", global::System.Management.Automation.CompletionResultType.ParameterValue, "S384xxm"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S448".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S448'", "S448", global::System.Management.Automation.CompletionResultType.ParameterValue, "S448"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S448m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S448m'", "S448m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S448m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S448om".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S448om'", "S448om", global::System.Management.Automation.CompletionResultType.ParameterValue, "S448om"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S448oo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S448oo'", "S448oo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S448oo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S448oom".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S448oom'", "S448oom", global::System.Management.Automation.CompletionResultType.ParameterValue, "S448oom"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S448ooo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S448ooo'", "S448ooo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S448ooo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S576m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S576m'", "S576m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S576m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S576xm".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S576xm'", "S576xm", global::System.Management.Automation.CompletionResultType.ParameterValue, "S576xm"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S672".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S672'", "S672", global::System.Management.Automation.CompletionResultType.ParameterValue, "S672"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S672m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S672m'", "S672m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S672m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S672om".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S672om'", "S672om", global::System.Management.Automation.CompletionResultType.ParameterValue, "S672om"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S672oo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S672oo'", "S672oo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S672oo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S672oom".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S672oom'", "S672oom", global::System.Management.Automation.CompletionResultType.ParameterValue, "S672oom"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S672ooo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S672ooo'", "S672ooo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S672ooo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S768".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S768'", "S768", global::System.Management.Automation.CompletionResultType.ParameterValue, "S768"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S768m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S768m'", "S768m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S768m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S768xm".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S768xm'", "S768xm", global::System.Management.Automation.CompletionResultType.ParameterValue, "S768xm"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S896".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S896'", "S896", global::System.Management.Automation.CompletionResultType.ParameterValue, "S896"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S896m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S896m'", "S896m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S896m"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S896om".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S896om'", "S896om", global::System.Management.Automation.CompletionResultType.ParameterValue, "S896om"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S896oo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S896oo'", "S896oo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S896oo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S896oom".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S896oom'", "S896oom", global::System.Management.Automation.CompletionResultType.ParameterValue, "S896oom"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S896ooo".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S896ooo'", "S896ooo", global::System.Management.Automation.CompletionResultType.ParameterValue, "S896ooo"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "S960m".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'S960m'", "S960m", global::System.Management.Automation.CompletionResultType.ParameterValue, "S960m"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "Required".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'Required'", "Required", global::System.Management.Automation.CompletionResultType.ParameterValue, "Required"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "NotRequired".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("'NotRequired'", "NotRequired", global::System.Management.Automation.CompletionResultType.ParameterValue, "NotRequired"));
}
}
/// <summary>
/// Implementations of this function are called by PowerShell to complete arguments.
/// </summary>
/// <param name="commandName">The name of the command that needs argument completion.</param>
/// <param name="parameterName">The name of the parameter that needs argument completion.</param>
/// <param name="wordToComplete">The (possibly empty) word being completed.</param>
/// <param name="commandAst">The command ast in case it is needed for completion.</param>
/// <param name="fakeBoundParameters">This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot
/// or will not attempt to evaluate an argument, in which case you may need to use commandAst.</param>
/// <returns>
/// A collection of completion results, most like with ResultType set to ParameterValue.
/// </returns>
public global::System.Collections.Generic.IEnumerable <global::System.Management.Automation.CompletionResult> CompleteArgument(global::System.String commandName, global::System.String parameterName, global::System.String wordToComplete, global::System.Management.Automation.Language.CommandAst commandAst, global::System.Collections.IDictionary fakeBoundParameters)
{
if (global::System.String.IsNullOrEmpty(wordToComplete) || "encrypt".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("encrypt", "encrypt", global::System.Management.Automation.CompletionResultType.ParameterValue, "encrypt"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "decrypt".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("decrypt", "decrypt", global::System.Management.Automation.CompletionResultType.ParameterValue, "decrypt"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "wrapKey".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("wrapKey", "wrapKey", global::System.Management.Automation.CompletionResultType.ParameterValue, "wrapKey"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "unwrapKey".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("unwrapKey", "unwrapKey", global::System.Management.Automation.CompletionResultType.ParameterValue, "unwrapKey"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "sign".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("sign", "sign", global::System.Management.Automation.CompletionResultType.ParameterValue, "sign"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "verify".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("verify", "verify", global::System.Management.Automation.CompletionResultType.ParameterValue, "verify"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "get".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("get", "get", global::System.Management.Automation.CompletionResultType.ParameterValue, "get"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "list".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("list", "list", global::System.Management.Automation.CompletionResultType.ParameterValue, "list"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "create".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("create", "create", global::System.Management.Automation.CompletionResultType.ParameterValue, "create"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "update".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("update", "update", global::System.Management.Automation.CompletionResultType.ParameterValue, "update"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "import".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("import", "import", global::System.Management.Automation.CompletionResultType.ParameterValue, "import"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "delete".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("delete", "delete", global::System.Management.Automation.CompletionResultType.ParameterValue, "delete"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "backup".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("backup", "backup", global::System.Management.Automation.CompletionResultType.ParameterValue, "backup"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "restore".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("restore", "restore", global::System.Management.Automation.CompletionResultType.ParameterValue, "restore"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "recover".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("recover", "recover", global::System.Management.Automation.CompletionResultType.ParameterValue, "recover"));
}
if (global::System.String.IsNullOrEmpty(wordToComplete) || "purge".StartsWith(wordToComplete, global::System.StringComparison.InvariantCultureIgnoreCase))
{
yield return(new global::System.Management.Automation.CompletionResult("purge", "purge", global::System.Management.Automation.CompletionResultType.ParameterValue, "purge"));
}
}
