//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_BootSettingData.cs
//
//  Contents:   The AMT_BootSettingData class represents configuration-related and operational parameters for the boot service in the Intel(R) AMT.
//              This file was automatically generated from AMT_BootSettingData.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>
	///The AMT_BootSettingData class represents configuration-related and operational parameters for the boot service in the Intel(R) AMT.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_BootSettingData")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_BootSettingData", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_BootSettingData", IsNullable=false)]
	public class AMT_BootSettingData : CIM_BootSettingData
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_BootSettingData() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_BootSettingData(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_BootSettingData(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove BIOSLastStatus field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBIOSLastStatus()
		{
			RemoveField("BIOSLastStatus");
		}

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

		/// <summary>
		/// Optional, Last boot status reported by BIOS. 1st word (16 bit) contains general BIOS status (0 - Success, 1 - In Progress, 2 - Not Updated, 0xFFFF - Failed). 2nd word contains detailed error status (0 - Success/In Progress, 1 - General Drive Failure, 2 - Drive Password/Authentication Failure, 3 - Feature is not supported). This property is read only.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] BIOSLastStatus
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["BIOSLastStatus"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("BIOSLastStatus", arr);
			}
		}


		/// <summary>
		/// Required, When True, the BIOS pauses for user input on the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool BIOSPause
		{
			get
			{
				return bool.Parse(this["BIOSPause"][0]);
			}
			set
			{
				this.SetOrAddField("BIOSPause",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware enters the CMOS Setup screen on the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool BIOSSetup
		{
			get
			{
				return bool.Parse(this["BIOSSetup"][0]);
			}
			set
			{
				this.SetOrAddField("BIOSSetup",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, This property identifies the boot-media index for the managed client (when a boot source is set using the CIM_BootConfigSetting.ChangeBootOrder method). For Hard-Drive or CD/DVD boot - when the parameter value is 0, the default boot-media is booted. When the parameter value is 1, the primary boot-media is booted; when the value is 2, the secondary boot-media is booted; and so on. For PXE or diagnostics boot this property must be 0.
		/// </summary>
		[CimField(false, true)]
		public virtual ushort BootMediaIndex
		{
			get
			{
					return ushort.Parse(this["BootMediaIndex"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("BootMediaIndex",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BootguardStatus field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBootguardStatus()
		{
			RemoveField("BootguardStatus");
		}

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

		/// <summary>
		/// Optional, Bitmap that describes the status of Intel(R) Boot Guard (if for some reason AMT fails to get the Boot Guard status AMT shall return 0xffffffff)
		/// </summary>
		[CimField(false, false)]
		public virtual uint BootguardStatus
		{
			get
			{
					return uint.Parse(this["BootguardStatus"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("BootguardStatus",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware resets its non-volatile configuration data to the managed system's Setup defaults prior to booting the system.
		/// </summary>
		[CimField(false, true)]
		public virtual bool ConfigurationDataReset
		{
			get
			{
				return bool.Parse(this["ConfigurationDataReset"][0]);
			}
			set
			{
				this.SetOrAddField("ConfigurationDataReset",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EnforceSecureBoot field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEnforceSecureBoot()
		{
			RemoveField("EnforceSecureBoot");
		}

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

		/// <summary>
		/// Optional, When True, Secure boot over IDER is enforced on the next boot cycle, if IDER boot is used.
		/// </summary>
		[CimField(false, false)]
		public virtual bool EnforceSecureBoot
		{
			get
			{
				return bool.Parse(this["EnforceSecureBoot"][0]);
			}
			set
			{
				this.SetOrAddField("EnforceSecureBoot",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When set to a non-zero value, controls the amount of information the managed system writes to its local display.
		/// </summary>
		[CimField(false, true)]
		public virtual byte FirmwareVerbosity
		{
			get
			{
					return byte.Parse(this["FirmwareVerbosity"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("FirmwareVerbosity",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware transmits all progress PET events to the alert-sending device.
		/// </summary>
		[CimField(false, true)]
		public virtual bool ForcedProgressEvents
		{
			get
			{
				return bool.Parse(this["ForcedProgressEvents"][0]);
			}
			set
			{
				this.SetOrAddField("ForcedProgressEvents",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, Specifies the device to use when UseIder is set. 0 - Floppy Boot, 1- CD Boot.
		/// </summary>
		[CimField(false, true)]
		public virtual byte IDERBootDevice
		{
			get
			{
					return byte.Parse(this["IDERBootDevice"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("IDERBootDevice",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware disallows keyboard activity during its boot process.
		/// </summary>
		[CimField(false, true)]
		public virtual bool LockKeyboard
		{
			get
			{
				return bool.Parse(this["LockKeyboard"][0]);
			}
			set
			{
				this.SetOrAddField("LockKeyboard",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware disables the power button operation for the system, normally until the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool LockPowerButton
		{
			get
			{
				return bool.Parse(this["LockPowerButton"][0]);
			}
			set
			{
				this.SetOrAddField("LockPowerButton",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware disables the reset button operation for the system, normally until the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool LockResetButton
		{
			get
			{
				return bool.Parse(this["LockResetButton"][0]);
			}
			set
			{
				this.SetOrAddField("LockResetButton",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware disables the sleep button operation for the system, normally until the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool LockSleepButton
		{
			get
			{
				return bool.Parse(this["LockSleepButton"][0]);
			}
			set
			{
				this.SetOrAddField("LockSleepButton",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OptionsCleared field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOptionsCleared()
		{
			RemoveField("OptionsCleared");
		}

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

		/// <summary>
		/// Optional, Indicates whether the boot options have been cleared by BIOS or not. This property is read only.
		/// </summary>
		[CimField(false, false)]
		public virtual bool OptionsCleared
		{
			get
			{
				return bool.Parse(this["OptionsCleared"][0]);
			}
			set
			{
				this.SetOrAddField("OptionsCleared",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OwningEntity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemoveOwningEntity()
		{
			RemoveField("OwningEntity");
		}

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

		/// <summary>
		/// Optional, OwningEntity identifies the vendor or organization that defines the contained boot settings.
		/// </summary>
		[CimField(false, false)]
		public override string OwningEntity
		{
			get
			{
				return this.GetField("OwningEntity")[0];
			}
			set
			{
			this.SetOrAddField("OwningEntity",value);
			}
		}
		/// <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, When True, Remote Platform Erase will be performed by BIOS on the next boot cycle.
		/// </summary>
		[CimField(false, false)]
		public virtual bool PlatformErase
		{
			get
			{
				return bool.Parse(this["PlatformErase"][0]);
			}
			set
			{
				this.SetOrAddField("PlatformErase",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove RPEEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRPEEnabled()
		{
			RemoveField("RPEEnabled");
		}

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

		/// <summary>
		/// Optional, Reflects the enabled state of Remote Platform Erase from BIOS control POV, the WSMAN enabled state is in CIM_BootService WSMAN class
		/// </summary>
		[CimField(false, false)]
		public virtual bool RPEEnabled
		{
			get
			{
				return bool.Parse(this["RPEEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("RPEEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove RSEPassword field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRSEPassword()
		{
			RemoveField("RSEPassword");
		}

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

		/// <summary>
		/// Optional, SSD password for Remote Secure Erase operation. This is a write-only field, an empty string is returned when instance is read. When writing, an empty string or lack of field will be ignored. The password length is limited to 32 ASCII charachters. 
		/// </summary>
		[CimField(false, false)]
		public virtual string RSEPassword
		{
			get
			{
				return this.GetField("RSEPassword")[0];
			}
			set
			{
			this.SetOrAddField("RSEPassword",value);
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware reflashes the BIOS on the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool ReflashBIOS
		{
			get
			{
				return bool.Parse(this["ReflashBIOS"][0]);
			}
			set
			{
				this.SetOrAddField("ReflashBIOS",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SecureBootControlEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSecureBootControlEnabled()
		{
			RemoveField("SecureBootControlEnabled");
		}

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

		/// <summary>
		/// Optional, Reflects the enabled state of allowing Intel(R) AMT firmware to disable UEFI secure boot for OCR boot options
		/// </summary>
		[CimField(false, false)]
		public virtual bool SecureBootControlEnabled
		{
			get
			{
				return bool.Parse(this["SecureBootControlEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("SecureBootControlEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the BIOS performs secure erase operation.
		/// </summary>
		[CimField(false, true)]
		public virtual bool SecureErase
		{
			get
			{
				return bool.Parse(this["SecureErase"][0]);
			}
			set
			{
				this.SetOrAddField("SecureErase",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove UEFIHTTPSBootEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUEFIHTTPSBootEnabled()
		{
			RemoveField("UEFIHTTPSBootEnabled");
		}

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

		/// <summary>
		/// Optional, Reflects the enabled state of boot to OCR HTTPS server recovery boot option in the BIOS options
		/// </summary>
		[CimField(false, false)]
		public virtual bool UEFIHTTPSBootEnabled
		{
			get
			{
				return bool.Parse(this["UEFIHTTPSBootEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("UEFIHTTPSBootEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove UEFILocalPBABootEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUEFILocalPBABootEnabled()
		{
			RemoveField("UEFILocalPBABootEnabled");
		}

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

		/// <summary>
		/// Optional, Reflects the enabled state of boot to OCR local Pre-Boot Application (PBA) recovery boot option in the BIOS options
		/// </summary>
		[CimField(false, false)]
		public virtual bool UEFILocalPBABootEnabled
		{
			get
			{
				return bool.Parse(this["UEFILocalPBABootEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("UEFILocalPBABootEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove UefiBootNumberOfParams field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUefiBootNumberOfParams()
		{
			RemoveField("UefiBootNumberOfParams");
		}

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

		/// <summary>
		/// Optional, Reflects the number of parameters in the UefiBootParametersArray parameter array
		/// </summary>
		[CimField(false, false)]
		public virtual uint UefiBootNumberOfParams
		{
			get
			{
					return uint.Parse(this["UefiBootNumberOfParams"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("UefiBootNumberOfParams",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove UefiBootParametersArray field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUefiBootParametersArray()
		{
			RemoveField("UefiBootParametersArray");
		}

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

		/// <summary>
		/// Optional, The UEFI boot option parameters blob in Base64 encoding format, max size of data after Base64 decoding is 1024 bytes(Base64 encoding increases the size of the data by a factor of 1.333, hence the size of UefiBootParametersArray should be at least 1365 bytes)
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] UefiBootParametersArray
		{
			get
			{
					return Convert.FromBase64String(this.GetField("UefiBootParametersArray")[0]);			}
			set
			{
			this.SetOrAddField("UefiBootParametersArray",Convert.ToBase64String(value));
			}
		}


		/// <summary>
		/// Required, When True, IDER is used on the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool UseIDER
		{
			get
			{
				return bool.Parse(this["UseIDER"][0]);
			}
			set
			{
				this.SetOrAddField("UseIDER",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, Serial over LAN is used on the next boot cycle.
		/// </summary>
		[CimField(false, true)]
		public virtual bool UseSOL
		{
			get
			{
				return bool.Parse(this["UseSOL"][0]);
			}
			set
			{
				this.SetOrAddField("UseSOL",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When a Hard-drive boot source is chosen (using CIM_BootConfigSetting) and this property is set to True, the Intel(R) AMT firmware will boot in safe mode.
		/// </summary>
		[CimField(false, true)]
		public virtual bool UseSafeMode
		{
			get
			{
				return bool.Parse(this["UseSafeMode"][0]);
			}
			set
			{
				this.SetOrAddField("UseSafeMode",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, When True, the Intel(R) AMT firmware boots the system and bypasses any user or boot password that might be set in the system.
		/// </summary>
		[CimField(false, true)]
		public virtual bool UserPasswordBypass
		{
			get
			{
				return bool.Parse(this["UserPasswordBypass"][0]);
			}
			set
			{
				this.SetOrAddField("UserPasswordBypass",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove WinREBootEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveWinREBootEnabled()
		{
			RemoveField("WinREBootEnabled");
		}

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

		/// <summary>
		/// Optional, Reflects the enabled state of boot to OCR WinRE recovery boot option in the BIOS options
		/// </summary>
		[CimField(false, false)]
		public virtual bool WinREBootEnabled
		{
			get
			{
				return bool.Parse(this["WinREBootEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("WinREBootEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}

		/// <summary>
		/// Enumerate instances of AMT_BootSettingData 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_BootSettingData objects</returns>
		public static new Collection<AMT_BootSettingData> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
		{
			List<AMT_BootSettingData> ret = CimBase.Enumerate<AMT_BootSettingData>(client, cimKeys);
			return new Collection<AMT_BootSettingData>(ret);
		}

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


		/// <summary>
		/// Delete the instance of AMT_BootSettingData 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_BootSettingData>(client);
		}


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

		public new class CimKeys : CIM_BootSettingData.CimKeys
		{
		}

	}
}