//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_BootCapabilities.cs
//
//  Contents:   Boot options that the Intel(R) AMT device supports.
//              This file was automatically generated from AMT_BootCapabilities.mof
//
//----------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Globalization;
using System.Xml.Serialization;
using System.IO;
using Intel.Manageability.WSManagement;
using Intel.Manageability.Cim.Untyped;


namespace Intel.Manageability.Cim.Typed
{
	/// <summary>
	///Boot options that the Intel(R) AMT device supports.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_BootCapabilities")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_BootCapabilities", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_BootCapabilities", IsNullable=false)]
	public class AMT_BootCapabilities : CIM_Capabilities
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_BootCapabilities() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_BootCapabilities(string xml): base((IWSManClient)null)
		{
			this.Deserialize(xml);
		}
		/// <summary>
		/// Constructor which recieves a Ws-Management client object.
		/// </summary>
		/// <param name="client">Ws-Management client</param>
		public AMT_BootCapabilities(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AMTSecureBootControl field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAMTSecureBootControl()
		{
			RemoveField("AMTSecureBootControl");
		}

		/// <summary>
		/// Is true if the field AMTSecureBootControl exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool AMTSecureBootControlExist
		{
			get
			{
				return ContainsField("AMTSecureBootControl");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel (R) AMT device is privileged by UEFI to disable 'secure boot' for an AMT triggered boot option
		/// </summary>
		[CimField(false, false)]
		public virtual bool AMTSecureBootControl
		{
			get
			{
				return bool.Parse(this["AMTSecureBootControl"][0]);
			}
			set
			{
				this.SetOrAddField("AMTSecureBootControl",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BIOSPause field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBIOSPause()
		{
			RemoveField("BIOSPause");
		}

		/// <summary>
		/// Is true if the field BIOSPause exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool BIOSPauseExist
		{
			get
			{
				return ContainsField("BIOSPause");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'BIOS Pause'
		/// </summary>
		[CimField(false, false)]
		public virtual bool BIOSPause
		{
			get
			{
				return bool.Parse(this["BIOSPause"][0]);
			}
			set
			{
				this.SetOrAddField("BIOSPause",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BIOSReflash field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBIOSReflash()
		{
			RemoveField("BIOSReflash");
		}

		/// <summary>
		/// Is true if the field BIOSReflash exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool BIOSReflashExist
		{
			get
			{
				return ContainsField("BIOSReflash");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'BIOS Reflash'
		/// </summary>
		[CimField(false, false)]
		public virtual bool BIOSReflash
		{
			get
			{
				return bool.Parse(this["BIOSReflash"][0]);
			}
			set
			{
				this.SetOrAddField("BIOSReflash",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BIOSSecureBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBIOSSecureBoot()
		{
			RemoveField("BIOSSecureBoot");
		}

		/// <summary>
		/// Is true if the field BIOSSecureBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool BIOSSecureBootExist
		{
			get
			{
				return ContainsField("BIOSSecureBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'BIOS Secure Boot'
		/// </summary>
		[CimField(false, false)]
		public virtual bool BIOSSecureBoot
		{
			get
			{
				return bool.Parse(this["BIOSSecureBoot"][0]);
			}
			set
			{
				this.SetOrAddField("BIOSSecureBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BIOSSetup field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBIOSSetup()
		{
			RemoveField("BIOSSetup");
		}

		/// <summary>
		/// Is true if the field BIOSSetup exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool BIOSSetupExist
		{
			get
			{
				return ContainsField("BIOSSetup");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'BIOS Setup'
		/// </summary>
		[CimField(false, false)]
		public virtual bool BIOSSetup
		{
			get
			{
				return bool.Parse(this["BIOSSetup"][0]);
			}
			set
			{
				this.SetOrAddField("BIOSSetup",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ConfigurationDataReset field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveConfigurationDataReset()
		{
			RemoveField("ConfigurationDataReset");
		}

		/// <summary>
		/// Is true if the field ConfigurationDataReset exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ConfigurationDataResetExist
		{
			get
			{
				return ContainsField("ConfigurationDataReset");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Configuration Data Reset'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ConfigurationDataReset
		{
			get
			{
				return bool.Parse(this["ConfigurationDataReset"][0]);
			}
			set
			{
				this.SetOrAddField("ConfigurationDataReset",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceCDorDVDBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceCDorDVDBoot()
		{
			RemoveField("ForceCDorDVDBoot");
		}

		/// <summary>
		/// Is true if the field ForceCDorDVDBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceCDorDVDBootExist
		{
			get
			{
				return ContainsField("ForceCDorDVDBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Force CD or DVD Boot'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceCDorDVDBoot
		{
			get
			{
				return bool.Parse(this["ForceCDorDVDBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceCDorDVDBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceDiagnosticBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceDiagnosticBoot()
		{
			RemoveField("ForceDiagnosticBoot");
		}

		/// <summary>
		/// Is true if the field ForceDiagnosticBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceDiagnosticBootExist
		{
			get
			{
				return ContainsField("ForceDiagnosticBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Force Diagnostic Boot'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceDiagnosticBoot
		{
			get
			{
				return bool.Parse(this["ForceDiagnosticBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceDiagnosticBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceHardDriveBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceHardDriveBoot()
		{
			RemoveField("ForceHardDriveBoot");
		}

		/// <summary>
		/// Is true if the field ForceHardDriveBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceHardDriveBootExist
		{
			get
			{
				return ContainsField("ForceHardDriveBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Force Hard Drive Boot'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceHardDriveBoot
		{
			get
			{
				return bool.Parse(this["ForceHardDriveBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceHardDriveBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceHardDriveSafeModeBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceHardDriveSafeModeBoot()
		{
			RemoveField("ForceHardDriveSafeModeBoot");
		}

		/// <summary>
		/// Is true if the field ForceHardDriveSafeModeBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceHardDriveSafeModeBootExist
		{
			get
			{
				return ContainsField("ForceHardDriveSafeModeBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Force Hard Drive Safe Mode Boot'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceHardDriveSafeModeBoot
		{
			get
			{
				return bool.Parse(this["ForceHardDriveSafeModeBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceHardDriveSafeModeBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForcePXEBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForcePXEBoot()
		{
			RemoveField("ForcePXEBoot");
		}

		/// <summary>
		/// Is true if the field ForcePXEBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForcePXEBootExist
		{
			get
			{
				return ContainsField("ForcePXEBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Force PXE Boot'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForcePXEBoot
		{
			get
			{
				return bool.Parse(this["ForcePXEBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForcePXEBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceUEFIHTTPSBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceUEFIHTTPSBoot()
		{
			RemoveField("ForceUEFIHTTPSBoot");
		}

		/// <summary>
		/// Is true if the field ForceUEFIHTTPSBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceUEFIHTTPSBootExist
		{
			get
			{
				return ContainsField("ForceUEFIHTTPSBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports invoking force boot to 'HTTPS server'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceUEFIHTTPSBoot
		{
			get
			{
				return bool.Parse(this["ForceUEFIHTTPSBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceUEFIHTTPSBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceUEFIPBABoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceUEFIPBABoot()
		{
			RemoveField("ForceUEFIPBABoot");
		}

		/// <summary>
		/// Is true if the field ForceUEFIPBABoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceUEFIPBABootExist
		{
			get
			{
				return ContainsField("ForceUEFIPBABoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports invoking force boot to 'local PBA'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceUEFIPBABoot
		{
			get
			{
				return bool.Parse(this["ForceUEFIPBABoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceUEFIPBABoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForceWinREBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForceWinREBoot()
		{
			RemoveField("ForceWinREBoot");
		}

		/// <summary>
		/// Is true if the field ForceWinREBoot exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForceWinREBootExist
		{
			get
			{
				return ContainsField("ForceWinREBoot");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports invoking force boot to 'WinRE'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForceWinREBoot
		{
			get
			{
				return bool.Parse(this["ForceWinREBoot"][0]);
			}
			set
			{
				this.SetOrAddField("ForceWinREBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ForcedProgressEvents field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveForcedProgressEvents()
		{
			RemoveField("ForcedProgressEvents");
		}

		/// <summary>
		/// Is true if the field ForcedProgressEvents exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ForcedProgressEventsExist
		{
			get
			{
				return ContainsField("ForcedProgressEvents");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Forced Progress Events'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ForcedProgressEvents
		{
			get
			{
				return bool.Parse(this["ForcedProgressEvents"][0]);
			}
			set
			{
				this.SetOrAddField("ForcedProgressEvents",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove IDER field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIDER()
		{
			RemoveField("IDER");
		}

		/// <summary>
		/// Is true if the field IDER exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool IDERExist
		{
			get
			{
				return ContainsField("IDER");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'IDE Redirection'
		/// </summary>
		[CimField(false, false)]
		public virtual bool IDER
		{
			get
			{
				return bool.Parse(this["IDER"][0]);
			}
			set
			{
				this.SetOrAddField("IDER",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove KeyboardLock field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveKeyboardLock()
		{
			RemoveField("KeyboardLock");
		}

		/// <summary>
		/// Is true if the field KeyboardLock exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool KeyboardLockExist
		{
			get
			{
				return ContainsField("KeyboardLock");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Keyboard Lock'
		/// </summary>
		[CimField(false, false)]
		public virtual bool KeyboardLock
		{
			get
			{
				return bool.Parse(this["KeyboardLock"][0]);
			}
			set
			{
				this.SetOrAddField("KeyboardLock",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PlatformErase field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePlatformErase()
		{
			RemoveField("PlatformErase");
		}

		/// <summary>
		/// Is true if the field PlatformErase exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool PlatformEraseExist
		{
			get
			{
				return ContainsField("PlatformErase");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel (R) AMT device supports 'Remote Platform Erase', and which devices are supported in these process
		/// </summary>
		[CimField(false, false)]
		public virtual uint PlatformErase
		{
			get
			{
					return uint.Parse(this["PlatformErase"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PlatformErase",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PowerButtonLock field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePowerButtonLock()
		{
			RemoveField("PowerButtonLock");
		}

		/// <summary>
		/// Is true if the field PowerButtonLock exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool PowerButtonLockExist
		{
			get
			{
				return ContainsField("PowerButtonLock");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Power Button Lock'
		/// </summary>
		[CimField(false, false)]
		public virtual bool PowerButtonLock
		{
			get
			{
				return bool.Parse(this["PowerButtonLock"][0]);
			}
			set
			{
				this.SetOrAddField("PowerButtonLock",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ResetButtonLock field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveResetButtonLock()
		{
			RemoveField("ResetButtonLock");
		}

		/// <summary>
		/// Is true if the field ResetButtonLock exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ResetButtonLockExist
		{
			get
			{
				return ContainsField("ResetButtonLock");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Reset Button Lock'
		/// </summary>
		[CimField(false, false)]
		public virtual bool ResetButtonLock
		{
			get
			{
				return bool.Parse(this["ResetButtonLock"][0]);
			}
			set
			{
				this.SetOrAddField("ResetButtonLock",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SOL field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSOL()
		{
			RemoveField("SOL");
		}

		/// <summary>
		/// Is true if the field SOL exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool SOLExist
		{
			get
			{
				return ContainsField("SOL");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Serial Over Lan'
		/// </summary>
		[CimField(false, false)]
		public virtual bool SOL
		{
			get
			{
				return bool.Parse(this["SOL"][0]);
			}
			set
			{
				this.SetOrAddField("SOL",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SecureErase field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSecureErase()
		{
			RemoveField("SecureErase");
		}

		/// <summary>
		/// Is true if the field SecureErase exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool SecureEraseExist
		{
			get
			{
				return ContainsField("SecureErase");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Secure Erase'
		/// </summary>
		[CimField(false, false)]
		public virtual bool SecureErase
		{
			get
			{
				return bool.Parse(this["SecureErase"][0]);
			}
			set
			{
				this.SetOrAddField("SecureErase",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SleepButtonLock field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSleepButtonLock()
		{
			RemoveField("SleepButtonLock");
		}

		/// <summary>
		/// Is true if the field SleepButtonLock exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool SleepButtonLockExist
		{
			get
			{
				return ContainsField("SleepButtonLock");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Sleep Button Lock'
		/// </summary>
		[CimField(false, false)]
		public virtual bool SleepButtonLock
		{
			get
			{
				return bool.Parse(this["SleepButtonLock"][0]);
			}
			set
			{
				this.SetOrAddField("SleepButtonLock",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove UEFIWiFiCoExistenceAndProfileShare field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUEFIWiFiCoExistenceAndProfileShare()
		{
			RemoveField("UEFIWiFiCoExistenceAndProfileShare");
		}

		/// <summary>
		/// Is true if the field UEFIWiFiCoExistenceAndProfileShare exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool UEFIWiFiCoExistenceAndProfileShareExist
		{
			get
			{
				return ContainsField("UEFIWiFiCoExistenceAndProfileShare");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel (R) AMT device supports WiFi co-existence and profile share with UEFI
		/// </summary>
		[CimField(false, false)]
		public virtual bool UEFIWiFiCoExistenceAndProfileShare
		{
			get
			{
				return bool.Parse(this["UEFIWiFiCoExistenceAndProfileShare"][0]);
			}
			set
			{
				this.SetOrAddField("UEFIWiFiCoExistenceAndProfileShare",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove UserPasswordBypass field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUserPasswordBypass()
		{
			RemoveField("UserPasswordBypass");
		}

		/// <summary>
		/// Is true if the field UserPasswordBypass exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool UserPasswordBypassExist
		{
			get
			{
				return ContainsField("UserPasswordBypass");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'User Password Bypass'
		/// </summary>
		[CimField(false, false)]
		public virtual bool UserPasswordBypass
		{
			get
			{
				return bool.Parse(this["UserPasswordBypass"][0]);
			}
			set
			{
				this.SetOrAddField("UserPasswordBypass",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove VerbosityQuiet field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveVerbosityQuiet()
		{
			RemoveField("VerbosityQuiet");
		}

		/// <summary>
		/// Is true if the field VerbosityQuiet exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool VerbosityQuietExist
		{
			get
			{
				return ContainsField("VerbosityQuiet");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Verbosity/Quiet'
		/// </summary>
		[CimField(false, false)]
		public virtual bool VerbosityQuiet
		{
			get
			{
				return bool.Parse(this["VerbosityQuiet"][0]);
			}
			set
			{
				this.SetOrAddField("VerbosityQuiet",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove VerbosityScreenBlank field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveVerbosityScreenBlank()
		{
			RemoveField("VerbosityScreenBlank");
		}

		/// <summary>
		/// Is true if the field VerbosityScreenBlank exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool VerbosityScreenBlankExist
		{
			get
			{
				return ContainsField("VerbosityScreenBlank");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Verbosity Screen Blank'
		/// </summary>
		[CimField(false, false)]
		public virtual bool VerbosityScreenBlank
		{
			get
			{
				return bool.Parse(this["VerbosityScreenBlank"][0]);
			}
			set
			{
				this.SetOrAddField("VerbosityScreenBlank",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove VerbosityVerbose field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveVerbosityVerbose()
		{
			RemoveField("VerbosityVerbose");
		}

		/// <summary>
		/// Is true if the field VerbosityVerbose exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool VerbosityVerboseExist
		{
			get
			{
				return ContainsField("VerbosityVerbose");
			}
		}

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT device supports 'Verbosity/Verbose'
		/// </summary>
		[CimField(false, false)]
		public virtual bool VerbosityVerbose
		{
			get
			{
				return bool.Parse(this["VerbosityVerbose"][0]);
			}
			set
			{
				this.SetOrAddField("VerbosityVerbose",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}

		/// <summary>
		/// Enumerate instances of AMT_BootCapabilities class at an endpoint.
		/// </summary>
		/// <param name="client">WS-Management client</param>
		/// <param name="cimKeys">Keys for selecting the instances</param>
		/// <returns>Collection of AMT_BootCapabilities objects</returns>
		public static new Collection<AMT_BootCapabilities> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
		{
			List<AMT_BootCapabilities> ret = CimBase.Enumerate<AMT_BootCapabilities>(client, cimKeys);
			return new Collection<AMT_BootCapabilities>(ret);
		}

		/// <summary>
		/// Enumerate instances of AMT_BootCapabilities class at an endpoint.
		/// </summary>
		/// <param name="client">WS-Management client</param>
		/// <returns>Collection of AMT_BootCapabilities objects</returns>
		public static new Collection<AMT_BootCapabilities> Enumerate(IWSManClient client)
		{
			List<AMT_BootCapabilities> ret = CimBase.Enumerate<AMT_BootCapabilities>(client);
			return new Collection<AMT_BootCapabilities>(ret);
		}


		/// <summary>
		/// Delete the instance of AMT_BootCapabilities if it is singular.
		/// Note: This method will succeed only if a single instance of the class exists.
		/// </summary>
		/// <param name="client">WS-Management client</param>
		public static new void Delete(IWSManClient client)
		{
			CimBase.Delete<AMT_BootCapabilities>(client);
		}


		/// <summary>
		/// Represents the keys of the AMT_BootCapabilities class.
		/// </summary>

		public new class CimKeys : CIM_Capabilities.CimKeys
		{
		}

	}
}