generated/cmdlets/SetCVVMGroup_UpdateExpanded.cs

// Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.9.2, generator: @autorest/powershell@3.0.494)
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

namespace Commvault.Powershell.Cmdlets
{
    using static Commvault.Powershell.Runtime.Extensions;
    using System;

    /// <summary>Updates the VM Group</summary>
    /// <remarks>
    /// [OpenAPI] UpdateVMGroup=>PUT:"/V4/VmGroup/{VmGroupId}"
    /// </remarks>
    [global::System.Management.Automation.Cmdlet(global::System.Management.Automation.VerbsCommon.Set, @"CVVMGroup_UpdateExpanded", SupportsShouldProcess = true)]
    [global::System.Management.Automation.OutputType(typeof(Commvault.Powershell.Models.IGetVMGroupResp), typeof(Commvault.Powershell.Models.IGenericResp))]
    [global::Commvault.Powershell.Description(@"Updates the VM Group")]
    [global::Commvault.Powershell.Generated]
    public partial class SetCVVMGroup_UpdateExpanded : global::System.Management.Automation.PSCmdlet,
        Commvault.Powershell.Runtime.IEventListener
    {
        /// <summary>A copy of the Invocation Info (necessary to allow asJob to clone this cmdlet)</summary>
        private global::System.Management.Automation.InvocationInfo __invocationInfo;

        /// <summary>UpdatevmGroupReq</summary>
        private Commvault.Powershell.Models.IUpdatevmGroupReq _body = new Commvault.Powershell.Models.UpdatevmGroupReq();

        /// <summary>
        /// The <see cref="global::System.Threading.CancellationTokenSource" /> for this operation.
        /// </summary>
        private global::System.Threading.CancellationTokenSource _cancellationTokenSource = new global::System.Threading.CancellationTokenSource();

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"accessNode",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IIdName) })]
        public Commvault.Powershell.Models.IIdName[] AccessNode { get => _body.AccessNode ?? null /* arrayOf */; set => _body.AccessNode = value; }

        /// <summary>true if Backup is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "true if Backup is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"true if Backup is enabled",
        SerializedName = @"enableBackup",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter ActivityControlEnableBackup { get => _body.ActivityControlEnableBackup ?? default(global::System.Management.Automation.SwitchParameter); set => _body.ActivityControlEnableBackup = value; }

        /// <summary>true if Restore is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "true if Restore is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"true if Restore is enabled",
        SerializedName = @"enableRestore",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter ActivityControlEnableRestore { get => _body.ActivityControlEnableRestore ?? default(global::System.Management.Automation.SwitchParameter); set => _body.ActivityControlEnableRestore = value; }

        /// <summary>vmAppValidation</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "vmAppValidation")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"vmAppValidation",
        SerializedName = @"applicationValidation",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IVMAppValidation) })]
        public Commvault.Powershell.Models.IVMAppValidation ApplicationValidation { get => _body.ApplicationValidation ?? null /* object */; set => _body.ApplicationValidation = value; }

        /// <summary>Delayed by n Hrs</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Delayed by n Hrs")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Delayed by n Hrs",
        SerializedName = @"delayTime",
        PossibleTypes = new [] { typeof(string) })]
        public string BackupActivityControlOptionDelayTime { get => _body.BackupActivityControlOptionDelayTime ?? null; set => _body.BackupActivityControlOptionDelayTime = value; }

        /// <summary>True if the activity will be enabled after a delay time interval</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if the activity will be enabled after a delay time interval")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if the activity will be enabled after a delay time interval",
        SerializedName = @"enableAfterDelay",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter BackupActivityControlOptionEnableAfterDelay { get => _body.BackupActivityControlOptionEnableAfterDelay ?? default(global::System.Management.Automation.SwitchParameter); set => _body.BackupActivityControlOptionEnableAfterDelay = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long BackupActivityControlOptionsTimeZoneId { get => _body.BackupActivityControlOptionsTimeZoneId ?? default(long); set => _body.BackupActivityControlOptionsTimeZoneId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string BackupActivityControlOptionsTimeZoneName { get => _body.BackupActivityControlOptionsTimeZoneName ?? null; set => _body.BackupActivityControlOptionsTimeZoneName = value; }

        /// <summary>Wait for .NET debugger to attach</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, DontShow = true, HelpMessage = "Wait for .NET debugger to attach")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Runtime)]
        public global::System.Management.Automation.SwitchParameter Break { get; set; }

        /// <summary>The reference to the client API class.</summary>
        public Commvault.Powershell.CommvaultPowerShell Client => Commvault.Powershell.Module.Instance.ClientAPI;

        /// <summary>
        /// True if content in vmgroup has to be overwritten, by default it will append the content
        /// </summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if content in vmgroup has to be overwritten, by default it will append the content")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if content in vmgroup has to be overwritten, by default it will append the content",
        SerializedName = @"overwrite",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter ContentOverwrite { get => _body.ContentOverwrite ?? default(global::System.Management.Automation.SwitchParameter); set => _body.ContentOverwrite = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"ruleGroups",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IRuleGroupContent) })]
        public Commvault.Powershell.Models.IRuleGroupContent[] ContentRuleGroups { get => _body.ContentRuleGroups ?? null /* arrayOf */; set => _body.ContentRuleGroups = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"virtualMachines",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IVirtualMachinecontent) })]
        public Commvault.Powershell.Models.IVirtualMachinecontent[] ContentVirtualMachines { get => _body.ContentVirtualMachines ?? null /* arrayOf */; set => _body.ContentVirtualMachines = value; }

        /// <summary>username to access the network path</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "username to access the network path")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"username to access the network path",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string CredentialsName { get => _body.CredentialsName ?? null; set => _body.CredentialsName = value; }

        /// <summary>password to access the network path</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "password to access the network path")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"password to access the network path",
        SerializedName = @"password",
        PossibleTypes = new [] { typeof(string) })]
        public string CredentialsPassword { get => _body.CredentialsPassword ?? null; set => _body.CredentialsPassword = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long CrossAccountCopyDestinationClientId { get => _body.CrossAccountCopyDestinationClientId ?? default(long); set => _body.CrossAccountCopyDestinationClientId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string CrossAccountCopyDestinationClientName { get => _body.CrossAccountCopyDestinationClientName ?? null; set => _body.CrossAccountCopyDestinationClientName = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"diskFilters",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IVMDiskFilter) })]
        public Commvault.Powershell.Models.IVMDiskFilter[] DiskFilters { get => _body.DiskFilters ?? null /* arrayOf */; set => _body.DiskFilters = value; }

        /// <summary>True if file indexing needs to be enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if file indexing needs to be enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if file indexing needs to be enabled",
        SerializedName = @"enableFileIndexing",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter EnableFileIndexing { get => _body.EnableFileIndexing ?? default(global::System.Management.Automation.SwitchParameter); set => _body.EnableFileIndexing = value; }

        /// <summary>
        /// True if content in vmgroup has to be overwritten, by default it will append the content
        /// </summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if content in vmgroup has to be overwritten, by default it will append the content")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if content in vmgroup has to be overwritten, by default it will append the content",
        SerializedName = @"overwrite",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter FilterOverwrite { get => _body.FilterOverwrite ?? default(global::System.Management.Automation.SwitchParameter); set => _body.FilterOverwrite = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"ruleGroups",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IRuleGroupContent) })]
        public Commvault.Powershell.Models.IRuleGroupContent[] FilterRuleGroups { get => _body.FilterRuleGroups ?? null /* arrayOf */; set => _body.FilterRuleGroups = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"virtualMachines",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.IVirtualMachinecontent) })]
        public Commvault.Powershell.Models.IVirtualMachinecontent[] FilterVirtualMachines { get => _body.FilterVirtualMachines ?? null /* arrayOf */; set => _body.FilterVirtualMachines = value; }

        /// <summary>SendAsync Pipeline Steps to be appended to the front of the pipeline</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, DontShow = true, HelpMessage = "SendAsync Pipeline Steps to be appended to the front of the pipeline")]
        [global::System.Management.Automation.ValidateNotNull]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Runtime)]
        public Commvault.Powershell.Runtime.SendAsyncStep[] HttpPipelineAppend { get; set; }

        /// <summary>SendAsync Pipeline Steps to be prepended to the front of the pipeline</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, DontShow = true, HelpMessage = "SendAsync Pipeline Steps to be prepended to the front of the pipeline")]
        [global::System.Management.Automation.ValidateNotNull]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Runtime)]
        public Commvault.Powershell.Runtime.SendAsyncStep[] HttpPipelinePrepend { get; set; }

        /// <summary>Accessor for our copy of the InvocationInfo.</summary>
        public global::System.Management.Automation.InvocationInfo InvocationInformation { get => __invocationInfo = __invocationInfo ?? this.MyInvocation ; set { __invocationInfo = value; } }

        /// <summary>
        /// <see cref="Commvault.Powershell.Runtime.IEventListener" /> cancellation delegate. Stops the cmdlet when called.
        /// </summary>
        global::System.Action Commvault.Powershell.Runtime.IEventListener.Cancel => _cancellationTokenSource.Cancel;

        /// <summary><see cref="Commvault.Powershell.Runtime.IEventListener" /> cancellation token.</summary>
        global::System.Threading.CancellationToken Commvault.Powershell.Runtime.IEventListener.Token => _cancellationTokenSource.Token;

        /// <summary>subclient name</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "subclient name ")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"subclient name ",
        SerializedName = @"newName",
        PossibleTypes = new [] { typeof(string) })]
        public string NewName { get => _body.NewName ?? null; set => _body.NewName = value; }

        /// <summary>
        /// The instance of the <see cref="Commvault.Powershell.Runtime.HttpPipeline" /> that the remote call will use.
        /// </summary>
        private Commvault.Powershell.Runtime.HttpPipeline Pipeline { get; set; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long PlanId { get => _body.PlanId ?? default(long); set => _body.PlanId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string PlanName { get => _body.PlanName ?? null; set => _body.PlanName = value; }

        /// <summary>The URI for the proxy server to use</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, DontShow = true, HelpMessage = "The URI for the proxy server to use")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Runtime)]
        public global::System.Uri Proxy { get; set; }

        /// <summary>Credentials for a proxy server to use for the remote call</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, DontShow = true, HelpMessage = "Credentials for a proxy server to use for the remote call")]
        [global::System.Management.Automation.ValidateNotNull]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Runtime)]
        public global::System.Management.Automation.PSCredential ProxyCredential { get; set; }

        /// <summary>Use the default credentials for the proxy</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, DontShow = true, HelpMessage = "Use the default credentials for the proxy")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Runtime)]
        public global::System.Management.Automation.SwitchParameter ProxyUseDefaultCredentials { get; set; }

        /// <summary>Delayed by n Hrs</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Delayed by n Hrs")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Delayed by n Hrs",
        SerializedName = @"delayTime",
        PossibleTypes = new [] { typeof(string) })]
        public string RestoreActivityControlOptionDelayTime { get => _body.RestoreActivityControlOptionDelayTime ?? null; set => _body.RestoreActivityControlOptionDelayTime = value; }

        /// <summary>True if the activity will be enabled after a delay time interval</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if the activity will be enabled after a delay time interval")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if the activity will be enabled after a delay time interval",
        SerializedName = @"enableAfterDelay",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter RestoreActivityControlOptionEnableAfterDelay { get => _body.RestoreActivityControlOptionEnableAfterDelay ?? default(global::System.Management.Automation.SwitchParameter); set => _body.RestoreActivityControlOptionEnableAfterDelay = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long RestoreActivityControlOptionsTimeZoneId { get => _body.RestoreActivityControlOptionsTimeZoneId ?? default(long); set => _body.RestoreActivityControlOptionsTimeZoneId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string RestoreActivityControlOptionsTimeZoneName { get => _body.RestoreActivityControlOptionsTimeZoneName ?? null; set => _body.RestoreActivityControlOptionsTimeZoneName = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long SavedCredentialsId { get => _body.SavedCredentialsId ?? default(long); set => _body.SavedCredentialsId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string SavedCredentialsName { get => _body.SavedCredentialsName ?? null; set => _body.SavedCredentialsName = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.AllowEmptyCollection]
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"securityAssociations",
        PossibleTypes = new [] { typeof(Commvault.Powershell.Models.ISecurityAssoc) })]
        public Commvault.Powershell.Models.ISecurityAssoc[] SecurityAssociations { get => _body.SecurityAssociations ?? null /* arrayOf */; set => _body.SecurityAssociations = value; }

        /// <summary>True if auto detect VM Owner enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if auto detect VM Owner enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if auto detect VM Owner enabled",
        SerializedName = @"autoDetectVMOwner",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingAutoDetectVMOwner { get => _body.SettingAutoDetectVMOwner ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingAutoDetectVMOwner = value; }

        /// <summary>
        /// True if metadata collection is enabled for intellisnap jobs. Only applicable for Indexing v1
        /// </summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if metadata collection is enabled for intellisnap jobs. Only applicable for Indexing v1")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if metadata collection is enabled for intellisnap jobs. Only applicable for Indexing v1",
        SerializedName = @"collectFileDetailsFromSnapshotCopy",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingCollectFileDetailsFromSnapshotCopy { get => _body.SettingCollectFileDetailsFromSnapshotCopy ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingCollectFileDetailsFromSnapshotCopy = value; }

        /// <summary>True if metadata collection is enabled. Only applicable for Indexing v1</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if metadata collection is enabled. Only applicable for Indexing v1")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if metadata collection is enabled. Only applicable for Indexing v1",
        SerializedName = @"collectFileDetailsforGranularRecovery",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingCollectFileDetailsforGranularRecovery { get => _body.SettingCollectFileDetailsforGranularRecovery ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingCollectFileDetailsforGranularRecovery = value; }

        /// <summary>Custom snapshot resource group GUID for Azure</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Custom snapshot resource group GUID for Azure")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Custom snapshot resource group GUID for Azure",
        SerializedName = @"customSnapshotResourceGroup",
        PossibleTypes = new [] { typeof(string) })]
        public string SettingCustomSnapshotResourceGroup { get => _body.SettingCustomSnapshotResourceGroup ?? null; set => _body.SettingCustomSnapshotResourceGroup = value; }

        /// <summary>True if Datastore Free space check is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if Datastore Free space check is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if Datastore Free space check is enabled",
        SerializedName = @"datastoreFreespaceCheck",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingDatastoreFreespaceCheck { get => _body.SettingDatastoreFreespaceCheck ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingDatastoreFreespaceCheck = value; }

        /// <summary>precentage of datastore free space check value</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "precentage of datastore free space check value")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"precentage of datastore free space check value",
        SerializedName = @"datastoreFreespaceRequired",
        PossibleTypes = new [] { typeof(long) })]
        public long SettingDatastoreFreespaceRequired { get => _body.SettingDatastoreFreespaceRequired ?? default(long); set => _body.SettingDatastoreFreespaceRequired = value; }

        /// <summary>Is the VM App Aware</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Is the VM App Aware")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Is the VM App Aware",
        SerializedName = @"isApplicationAware",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingIsApplicationAware { get => _body.SettingIsApplicationAware ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingIsApplicationAware = value; }

        /// <summary>Start Time for the VM Group Job</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Start Time for the VM Group Job")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Start Time for the VM Group Job",
        SerializedName = @"jobStartTime",
        PossibleTypes = new [] { typeof(long) })]
        public long SettingJobStartTime { get => _body.SettingJobStartTime ?? default(long); set => _body.SettingJobStartTime = value; }

        /// <summary>Number of readers for backup</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Number of readers for backup")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Number of readers for backup",
        SerializedName = @"noOfReaders",
        PossibleTypes = new [] { typeof(long) })]
        public long SettingNoOfReaders { get => _body.SettingNoOfReaders ?? default(long); set => _body.SettingNoOfReaders = value; }

        /// <summary>transport mode based on environment. Values are case sensitive</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "transport mode based on environment. Values are case sensitive")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"transport mode based on environment. Values are case sensitive",
        SerializedName = @"transportMode",
        PossibleTypes = new [] { typeof(string) })]
        public string SettingTransportMode { get => _body.SettingTransportMode ?? null; set => _body.SettingTransportMode = value; }

        /// <summary>True if Changed Block Tracking is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if Changed Block Tracking is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if Changed Block Tracking is enabled",
        SerializedName = @"useChangedBlockTrackingOnVM",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingUseChangedBlockTrackingOnVM { get => _body.SettingUseChangedBlockTrackingOnVM ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingUseChangedBlockTrackingOnVM = value; }

        /// <summary>True if use VM CheckPoint setting is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if use VM CheckPoint setting is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if use VM CheckPoint setting is enabled",
        SerializedName = @"useVMCheckpointSetting",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SettingUseVMCheckpointSetting { get => _body.SettingUseVMCheckpointSetting ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SettingUseVMCheckpointSetting = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"vmBackupType",
        PossibleTypes = new [] { typeof(string) })]
        public string SettingVMBackupType { get => _body.SettingVMBackupType ?? null; set => _body.SettingVMBackupType = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long SnapEngineId { get => _body.SnapEngineId ?? default(long); set => _body.SnapEngineId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string SnapEngineName { get => _body.SnapEngineName ?? null; set => _body.SnapEngineName = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long SnapMountProxyId { get => _body.SnapMountProxyId ?? default(long); set => _body.SnapMountProxyId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string SnapMountProxyName { get => _body.SnapMountProxyName ?? null; set => _body.SnapMountProxyName = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"backupCopyInterface",
        PossibleTypes = new [] { typeof(string) })]
        public string SnapshotManagementBackupCopyInterface { get => _body.SnapshotManagementBackupCopyInterface ?? null; set => _body.SnapshotManagementBackupCopyInterface = value; }

        /// <summary>True if hardware snapshot is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if hardware snapshot is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if hardware snapshot is enabled",
        SerializedName = @"enableHardwareSnapshot",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SnapshotManagementEnableHardwareSnapshot { get => _body.SnapshotManagementEnableHardwareSnapshot ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SnapshotManagementEnableHardwareSnapshot = value; }

        /// <summary>True if full copy of amazon snapshot to different amazon account is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if full copy of amazon snapshot to different amazon account is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if full copy of amazon snapshot to different amazon account is enabled",
        SerializedName = @"isCrossAccountCopyEnabled",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SnapshotManagementIsCrossAccountCopyEnabled { get => _body.SnapshotManagementIsCrossAccountCopyEnabled ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SnapshotManagementIsCrossAccountCopyEnabled = value; }

        /// <summary>
        /// True if replicate and copy or sharing of amazon snapshot to different amazon account in same or different geographic location
        /// is enabled
        /// </summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if replicate and copy or sharing of amazon snapshot to different amazon account in same or different geographic location is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if replicate and copy or sharing of amazon snapshot to different amazon account in same or different geographic location is enabled",
        SerializedName = @"isCrossAccountEnabled",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SnapshotManagementIsCrossAccountEnabled { get => _body.SnapshotManagementIsCrossAccountEnabled ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SnapshotManagementIsCrossAccountEnabled = value; }

        /// <summary>True if independent disk option is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if independent disk option is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if independent disk option is enabled",
        SerializedName = @"isIndependentDisksEnabled",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SnapshotManagementIsIndependentDisksEnabled { get => _body.SnapshotManagementIsIndependentDisksEnabled ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SnapshotManagementIsIndependentDisksEnabled = value; }

        /// <summary>True if raw device maps option is enabled</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if raw device maps option is enabled")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if raw device maps option is enabled",
        SerializedName = @"isRawDeviceMapsEnabled",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SnapshotManagementIsRawDeviceMapsEnabled { get => _body.SnapshotManagementIsRawDeviceMapsEnabled ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SnapshotManagementIsRawDeviceMapsEnabled = value; }

        /// <summary>Name of ESX Host</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Name of ESX Host")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Name of ESX Host",
        SerializedName = @"snapMountESXHost",
        PossibleTypes = new [] { typeof(string) })]
        public string SnapshotManagementSnapMountEsxHost { get => _body.SnapshotManagementSnapMountEsxHost ?? null; set => _body.SnapshotManagementSnapMountEsxHost = value; }

        /// <summary>True if separate proxy client is used for snap to tape</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "True if separate proxy client is used for snap to tape")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"True if separate proxy client is used for snap to tape",
        SerializedName = @"useSeparateProxyForSnapToTape",
        PossibleTypes = new [] { typeof(global::System.Management.Automation.SwitchParameter) })]
        public global::System.Management.Automation.SwitchParameter SnapshotManagementUseSeparateProxyForSnapToTape { get => _body.SnapshotManagementUseSeparateProxyForSnapToTape ?? default(global::System.Management.Automation.SwitchParameter); set => _body.SnapshotManagementUseSeparateProxyForSnapToTape = value; }

        /// <summary>Virtual machine application user name</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = "Virtual machine application user name")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @"Virtual machine application user name",
        SerializedName = @"vmApplicationUserName",
        PossibleTypes = new [] { typeof(string) })]
        public string SnapshotManagementVMApplicationUserName { get => _body.SnapshotManagementVMApplicationUserName ?? null; set => _body.SnapshotManagementVMApplicationUserName = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"id",
        PossibleTypes = new [] { typeof(long) })]
        public long StorageId { get => _body.StorageId ?? default(long); set => _body.StorageId = value; }

        /// <summary>.</summary>
        [global::System.Management.Automation.Parameter(Mandatory = false, HelpMessage = ".")]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Body)]
        [Commvault.Powershell.Runtime.Info(
        Required = false,
        ReadOnly = false,
        Description = @".",
        SerializedName = @"name",
        PossibleTypes = new [] { typeof(string) })]
        public string StorageName { get => _body.StorageName ?? null; set => _body.StorageName = value; }

        /// <summary>Backing field for <see cref="VMGroupId" /> property.</summary>
        private long _vMGroupId;

        /// <summary>Id of the VMgroup to update</summary>
        [global::System.Management.Automation.Parameter(Mandatory = true, HelpMessage = "Id of the VMgroup to update")]
        [Commvault.Powershell.Runtime.Info(
        Required = true,
        ReadOnly = false,
        Description = @"Id of the VMgroup to update",
        SerializedName = @"VmGroupId",
        PossibleTypes = new [] { typeof(long) })]
        [global::Commvault.Powershell.Category(global::Commvault.Powershell.ParameterCategory.Path)]
        public long VMGroupId { get => this._vMGroupId; set => this._vMGroupId = value; }

        /// <summary>
        /// <c>overrideOnBadRequest</c> will be called before the regular onBadRequest has been processed, allowing customization
        /// of what happens on that response. Implement this method in a partial class to enable this behavior
        /// </summary>
        /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
        /// <param name="response">the body result as a <see cref="Commvault.Powershell.Models.IGenericResp">Commvault.Powershell.Models.IGenericResp</see>
        /// from the remote call</param>
        /// <param name="returnNow">/// Determines if the rest of the onBadRequest method should be processed, or if the method should
        /// return immediately (set to true to skip further processing )</param>

        partial void overrideOnBadRequest(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task<Commvault.Powershell.Models.IGenericResp> response, ref global::System.Threading.Tasks.Task<bool> returnNow);

        /// <summary>
        /// <c>overrideOnInternalServerError</c> will be called before the regular onInternalServerError has been processed, allowing
        /// customization of what happens on that response. Implement this method in a partial class to enable this behavior
        /// </summary>
        /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
        /// <param name="response">the body result as a <see cref="Commvault.Powershell.Models.IGenericResp">Commvault.Powershell.Models.IGenericResp</see>
        /// from the remote call</param>
        /// <param name="returnNow">/// Determines if the rest of the onInternalServerError method should be processed, or if the
        /// method should return immediately (set to true to skip further processing )</param>

        partial void overrideOnInternalServerError(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task<Commvault.Powershell.Models.IGenericResp> response, ref global::System.Threading.Tasks.Task<bool> returnNow);

        /// <summary>
        /// <c>overrideOnOk</c> will be called before the regular onOk has been processed, allowing customization of what happens
        /// on that response. Implement this method in a partial class to enable this behavior
        /// </summary>
        /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
        /// <param name="response">the body result as a <see cref="Commvault.Powershell.Models.IGetVMGroupResp">Commvault.Powershell.Models.IGetVMGroupResp</see>
        /// from the remote call</param>
        /// <param name="returnNow">/// Determines if the rest of the onOk method should be processed, or if the method should return
        /// immediately (set to true to skip further processing )</param>

        partial void overrideOnOk(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task<Commvault.Powershell.Models.IGetVMGroupResp> response, ref global::System.Threading.Tasks.Task<bool> returnNow);

        /// <summary>
        /// (overrides the default BeginProcessing method in global::System.Management.Automation.PSCmdlet)
        /// </summary>
        protected override void BeginProcessing()
        {
            Module.Instance.SetProxyConfiguration(Proxy, ProxyCredential, ProxyUseDefaultCredentials);
            if (Break)
            {
                Commvault.Powershell.Runtime.AttachDebugger.Break();
            }
            ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletBeginProcessing).Wait(); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
        }

        /// <summary>Performs clean-up after the command execution</summary>
        protected override void EndProcessing()
        {
            ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletEndProcessing).Wait(); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
        }

        /// <summary>Handles/Dispatches events during the call to the REST service.</summary>
        /// <param name="id">The message id</param>
        /// <param name="token">The message cancellation token. When this call is cancelled, this should be <c>true</c></param>
        /// <param name="messageData">Detailed message data for the message event.</param>
        /// <returns>
        /// A <see cref="global::System.Threading.Tasks.Task" /> that will be complete when handling of the message is completed.
        /// </returns>
         async global::System.Threading.Tasks.Task Commvault.Powershell.Runtime.IEventListener.Signal(string id, global::System.Threading.CancellationToken token, global::System.Func<Commvault.Powershell.Runtime.EventData> messageData)
        {
            using( NoSynchronizationContext )
            {
                if (token.IsCancellationRequested)
                {
                    return ;
                }

                switch ( id )
                {
                    case Commvault.Powershell.Runtime.Events.Verbose:
                    {
                        WriteVerbose($"{(messageData().Message ?? global::System.String.Empty)}");
                        return ;
                    }
                    case Commvault.Powershell.Runtime.Events.Warning:
                    {
                        WriteWarning($"{(messageData().Message ?? global::System.String.Empty)}");
                        return ;
                    }
                    case Commvault.Powershell.Runtime.Events.Information:
                    {
                        var data = messageData();
                        WriteInformation(data.Message, new string[]{});
                        return ;
                    }
                    case Commvault.Powershell.Runtime.Events.Debug:
                    {
                        WriteDebug($"{(messageData().Message ?? global::System.String.Empty)}");
                        return ;
                    }
                    case Commvault.Powershell.Runtime.Events.Error:
                    {
                        WriteError(new global::System.Management.Automation.ErrorRecord( new global::System.Exception(messageData().Message), string.Empty, global::System.Management.Automation.ErrorCategory.NotSpecified, null ) );
                        return ;
                    }
                }
                await Commvault.Powershell.Module.Instance.Signal(id, token, messageData, (i,t,m) => ((Commvault.Powershell.Runtime.IEventListener)this).Signal(i,t,()=> Commvault.Powershell.Runtime.EventDataConverter.ConvertFrom( m() ) as Commvault.Powershell.Runtime.EventData ), InvocationInformation, this.ParameterSetName, null );
                if (token.IsCancellationRequested)
                {
                    return ;
                }
                WriteDebug($"{id}: {(messageData().Message ?? global::System.String.Empty)}");
            }
        }

        /// <summary>Performs execution of the command.</summary>
        protected override void ProcessRecord()
        {
            ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletProcessRecordStart).Wait(); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
            try
            {
                // work
                if (ShouldProcess($"Call remote 'UpdateVMGroup' operation"))
                {
                    using( var asyncCommandRuntime = new Commvault.Powershell.Runtime.PowerShell.AsyncCommandRuntime(this, ((Commvault.Powershell.Runtime.IEventListener)this).Token) )
                    {
                        asyncCommandRuntime.Wait( ProcessRecordAsync(),((Commvault.Powershell.Runtime.IEventListener)this).Token);
                    }
                }
            }
            catch (global::System.AggregateException aggregateException)
            {
                // unroll the inner exceptions to get the root cause
                foreach( var innerException in aggregateException.Flatten().InnerExceptions )
                {
                    ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletException, $"{innerException.GetType().Name} - {innerException.Message} : {innerException.StackTrace}").Wait(); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
                    // Write exception out to error channel.
                    WriteError( new global::System.Management.Automation.ErrorRecord(innerException,string.Empty, global::System.Management.Automation.ErrorCategory.NotSpecified, null) );
                }
            }
            catch (global::System.Exception exception) when ((exception as System.Management.Automation.PipelineStoppedException)== null || (exception as System.Management.Automation.PipelineStoppedException).InnerException != null)
            {
                ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletException, $"{exception.GetType().Name} - {exception.Message} : {exception.StackTrace}").Wait(); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
                // Write exception out to error channel.
                WriteError( new global::System.Management.Automation.ErrorRecord(exception,string.Empty, global::System.Management.Automation.ErrorCategory.NotSpecified, null) );
            }
            finally
            {
                ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletProcessRecordEnd).Wait();
            }
        }

        /// <summary>Performs execution of the command, working asynchronously if required.</summary>
        /// <returns>
        /// A <see cref="global::System.Threading.Tasks.Task" /> that will be complete when handling of the method is completed.
        /// </returns>
        protected async global::System.Threading.Tasks.Task ProcessRecordAsync()
        {
            using( NoSynchronizationContext )
            {
                await ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletProcessRecordAsyncStart); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
                await ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletGetPipeline); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
                Pipeline = Commvault.Powershell.Module.Instance.CreatePipeline(InvocationInformation, this.ParameterSetName);
                if (null != HttpPipelinePrepend)
                {
                    Pipeline.Prepend((this.CommandRuntime as Commvault.Powershell.Runtime.PowerShell.IAsyncCommandRuntimeExtensions)?.Wrap(HttpPipelinePrepend) ?? HttpPipelinePrepend);
                }
                if (null != HttpPipelineAppend)
                {
                    Pipeline.Append((this.CommandRuntime as Commvault.Powershell.Runtime.PowerShell.IAsyncCommandRuntimeExtensions)?.Wrap(HttpPipelineAppend) ?? HttpPipelineAppend);
                }
                // get the client instance
                try
                {
                    await ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletBeforeAPICall); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
                    await this.Client.UpdateVMGroup(VMGroupId, _body, onOk, onBadRequest, onInternalServerError, this, Pipeline);
                    await ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletAfterAPICall); if( ((Commvault.Powershell.Runtime.IEventListener)this).Token.IsCancellationRequested ) { return; }
                }
                catch (Commvault.Powershell.Runtime.UndeclaredResponseException urexception)
                {
                    WriteError(new global::System.Management.Automation.ErrorRecord(urexception, urexception.StatusCode.ToString(), global::System.Management.Automation.ErrorCategory.InvalidOperation, new { VMGroupId=VMGroupId,body=_body})
                    {
                      ErrorDetails = new global::System.Management.Automation.ErrorDetails(urexception.Message) { RecommendedAction = urexception.Action }
                    });
                }
                finally
                {
                    await ((Commvault.Powershell.Runtime.IEventListener)this).Signal(Commvault.Powershell.Runtime.Events.CmdletProcessRecordAsyncEnd);
                }
            }
        }

        /// <summary>
        /// Intializes a new instance of the <see cref="SetCVVMGroup_UpdateExpanded" /> cmdlet class.
        /// </summary>
        public SetCVVMGroup_UpdateExpanded()
        {

        }

        /// <summary>Interrupts currently running code within the command.</summary>
        protected override void StopProcessing()
        {
            ((Commvault.Powershell.Runtime.IEventListener)this).Cancel();
            base.StopProcessing();
        }

        /// <summary>a delegate that is called when the remote service returns 400 (BadRequest).</summary>
        /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
        /// <param name="response">the body result as a <see cref="Commvault.Powershell.Models.IGenericResp">Commvault.Powershell.Models.IGenericResp</see>
        /// from the remote call</param>
        /// <returns>
        /// A <see cref="global::System.Threading.Tasks.Task" /> that will be complete when handling of the method is completed.
        /// </returns>
        private async global::System.Threading.Tasks.Task onBadRequest(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task<Commvault.Powershell.Models.IGenericResp> response)
        {
            using( NoSynchronizationContext )
            {
                var _returnNow = global::System.Threading.Tasks.Task<bool>.FromResult(false);
                overrideOnBadRequest(responseMessage, response, ref _returnNow);
                // if overrideOnBadRequest has returned true, then return right away.
                if ((null != _returnNow && await _returnNow))
                {
                    return ;
                }
                // onBadRequest - response for 400 / application/json
                // (await response) // should be Commvault.Powershell.Models.IGenericResp
                WriteObject((await response));
            }
        }

        /// <summary>
        /// a delegate that is called when the remote service returns 500 (InternalServerError).
        /// </summary>
        /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
        /// <param name="response">the body result as a <see cref="Commvault.Powershell.Models.IGenericResp">Commvault.Powershell.Models.IGenericResp</see>
        /// from the remote call</param>
        /// <returns>
        /// A <see cref="global::System.Threading.Tasks.Task" /> that will be complete when handling of the method is completed.
        /// </returns>
        private async global::System.Threading.Tasks.Task onInternalServerError(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task<Commvault.Powershell.Models.IGenericResp> response)
        {
            using( NoSynchronizationContext )
            {
                var _returnNow = global::System.Threading.Tasks.Task<bool>.FromResult(false);
                overrideOnInternalServerError(responseMessage, response, ref _returnNow);
                // if overrideOnInternalServerError has returned true, then return right away.
                if ((null != _returnNow && await _returnNow))
                {
                    return ;
                }
                // onInternalServerError - response for 500 / application/json
                // (await response) // should be Commvault.Powershell.Models.IGenericResp
                WriteObject((await response));
            }
        }

        /// <summary>a delegate that is called when the remote service returns 200 (OK).</summary>
        /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param>
        /// <param name="response">the body result as a <see cref="Commvault.Powershell.Models.IGetVMGroupResp">Commvault.Powershell.Models.IGetVMGroupResp</see>
        /// from the remote call</param>
        /// <returns>
        /// A <see cref="global::System.Threading.Tasks.Task" /> that will be complete when handling of the method is completed.
        /// </returns>
        private async global::System.Threading.Tasks.Task onOk(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task<Commvault.Powershell.Models.IGetVMGroupResp> response)
        {
            using( NoSynchronizationContext )
            {
                var _returnNow = global::System.Threading.Tasks.Task<bool>.FromResult(false);
                overrideOnOk(responseMessage, response, ref _returnNow);
                // if overrideOnOk has returned true, then return right away.
                if ((null != _returnNow && await _returnNow))
                {
                    return ;
                }
                // onOk - response for 200 / application/json
                // (await response) // should be Commvault.Powershell.Models.IGetVMGroupResp
                WriteObject((await response));
            }
        }
    }
}