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

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

		/// <summary>
		/// Optional, When set to Disabled, the AMT OOB network interfaces (LAN and WLAN) are disabled including AMT user initiated applications, Environment Detection and RMCPPing. Since OOB networking is disabled, there will not be an option to enable it back remotely.
		/// </summary>
		[CimField(false, false)]
		public virtual uint AMTNetworkEnabled
		{
			get
			{
					return uint.Parse(this["AMTNetworkEnabled"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AMTNetworkEnabled",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DDNSPeriodicUpdateInterval field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDDNSPeriodicUpdateInterval()
		{
			RemoveField("DDNSPeriodicUpdateInterval");
		}

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

		/// <summary>
		/// Optional, Defines the interval at which the FW DDNS Update client will send periodic updates for all the RRs registered by FW. Should be set according to corporate DNS scavenging policy. Units are minutes. Can be : either 0, or 20 and over. A value of 0 disables periodic update. (The default value for this property is 24 hours - 1440 minutes).
		/// </summary>
		[CimField(false, false)]
		public virtual uint DDNSPeriodicUpdateInterval
		{
			get
			{
					return uint.Parse(this["DDNSPeriodicUpdateInterval"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("DDNSPeriodicUpdateInterval",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DDNSTTL field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDDNSTTL()
		{
			RemoveField("DDNSTTL");
		}

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

		/// <summary>
		/// Optional, Defines the Time To Live value (cachable time) of RRs registered by the FW DDNSUpdateClient. Units are seconds. (The default value for this property is 15 minutes).
		/// </summary>
		[CimField(false, false)]
		public virtual uint DDNSTTL
		{
			get
			{
					return uint.Parse(this["DDNSTTL"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("DDNSTTL",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DDNSUpdateByDHCPServerEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDDNSUpdateByDHCPServerEnabled()
		{
			RemoveField("DDNSUpdateByDHCPServerEnabled");
		}

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

		/// <summary>
		/// Optional, If the DDNS Update client in FW is  disabled then this property will define whether DDNS Update should be requested from the DHCP Server for the shared IPv4 address and shared FQDN. (The default value for this property is enabled)
		/// </summary>
		[CimField(false, false)]
		public virtual bool DDNSUpdateByDHCPServerEnabled
		{
			get
			{
				return bool.Parse(this["DDNSUpdateByDHCPServerEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("DDNSUpdateByDHCPServerEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DDNSUpdateEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDDNSUpdateEnabled()
		{
			RemoveField("DDNSUpdateEnabled");
		}

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

		/// <summary>
		/// Optional, Defines whether the Dynamic DNS Update Client in FW is enabled or not. (The default value for this property is disabled)
		/// </summary>
		[CimField(false, false)]
		public virtual bool DDNSUpdateEnabled
		{
			get
			{
				return bool.Parse(this["DDNSUpdateEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("DDNSUpdateEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DHCPSyncRequiresHostname field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDHCPSyncRequiresHostname()
		{
			RemoveField("DHCPSyncRequiresHostname");
		}

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

		/// <summary>
		/// Optional, Indicates whether synchornizing IP with host's DHCPv4 requires the host to provide a host name (DHCP option 12)
		/// </summary>
		[CimField(false, false)]
		public virtual uint DHCPSyncRequiresHostname
		{
			get
			{
					return uint.Parse(this["DHCPSyncRequiresHostname"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("DHCPSyncRequiresHostname",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DHCPv6ConfigurationTimeout field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDHCPv6ConfigurationTimeout()
		{
			RemoveField("DHCPv6ConfigurationTimeout");
		}

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

		/// <summary>
		/// Optional, Defines the Maximum Duration (DHCPv6 MRD for the Solicit Message) in seconds during which the Intel(R) ME FW tries to locate a DHCPv6 server. 0 - means try forever. The default value for this property is 0.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort DHCPv6ConfigurationTimeout
		{
			get
			{
					return ushort.Parse(this["DHCPv6ConfigurationTimeout"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("DHCPv6ConfigurationTimeout",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DigestRealm field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDigestRealm()
		{
			RemoveField("DigestRealm");
		}

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

		/// <summary>
		/// Optional, The Intel(R) AMT device Digest Authentication Realm parameter as defined by RFC 2617.
		/// </summary>
		[CimField(false, false)]
		public virtual string DigestRealm
		{
			get
			{
				return this.GetField("DigestRealm")[0];
			}
			set
			{
			this.SetOrAddField("DigestRealm",value);
			}
		}
		/// <summary>
		/// Remove DomainName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDomainName()
		{
			RemoveField("DomainName");
		}

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

		/// <summary>
		/// Optional, Intel(R) AMT domain name setting.
		/// </summary>
		[CimField(false, false)]
		public virtual string DomainName
		{
			get
			{
				return this.GetField("DomainName")[0];
			}
			set
			{
			this.SetOrAddField("DomainName",value);
			}
		}
		/// <summary>
		/// Remove HostName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveHostName()
		{
			RemoveField("HostName");
		}

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

		/// <summary>
		/// Optional, Intel(R) AMT host setting.
		/// </summary>
		[CimField(false, false)]
		public virtual string HostName
		{
			get
			{
				return this.GetField("HostName")[0];
			}
			set
			{
			this.SetOrAddField("HostName",value);
			}
		}
		/// <summary>
		/// Remove HostOSFQDN field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveHostOSFQDN()
		{
			RemoveField("HostOSFQDN");
		}

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

		/// <summary>
		/// Optional, Intel(R) AMT host OS FQDN. This value of host FQDN is needed for the case that FW is set with a dedicated FQDN - this allows the SW to correlate the FW name with the Host name.
		/// </summary>
		[CimField(false, false)]
		public virtual string HostOSFQDN
		{
			get
			{
				return this.GetField("HostOSFQDN")[0];
			}
			set
			{
			this.SetOrAddField("HostOSFQDN",value);
			}
		}
		/// <summary>
		/// Remove IdleWakeTimeout field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIdleWakeTimeout()
		{
			RemoveField("IdleWakeTimeout");
		}

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

		/// <summary>
		/// Optional, Defines the minimum time value, in minutes, that Intel(R) AMT will be powered after waking up from a sleep power state, or after the host enters sleep or off state.This timer value will be reloaded whenever Intel(R) AMT is servicing requests. Note: this setting may not be applicable under some power package definitions.
		/// </summary>
		[CimField(false, false)]
		public virtual uint IdleWakeTimeout
		{
			get
			{
					return uint.Parse(this["IdleWakeTimeout"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("IdleWakeTimeout",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Key, Required, Within the scope of the instantiating Namespace, InstanceID opaquely and uniquely identifies an instance of this class.
		/// </summary>
		[CimField(true, true)]
		public override string InstanceID
		{
			get
			{
				return this.GetField("InstanceID")[0];
			}
			set
			{
			this.SetOrAddField("InstanceID",value);
			}
		}
		/// <summary>
		/// Remove NetworkInterfaceEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveNetworkInterfaceEnabled()
		{
			RemoveField("NetworkInterfaceEnabled");
		}

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

		/// <summary>
		/// Optional, Indicates whether the network interface is enabled
		/// </summary>
		[CimField(false, false)]
		public virtual bool NetworkInterfaceEnabled
		{
			get
			{
				return bool.Parse(this["NetworkInterfaceEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("NetworkInterfaceEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OemID field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOemID()
		{
			RemoveField("OemID");
		}

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

		/// <summary>
		/// Optional, PCIe Vendor Unique ID
		/// </summary>
		[CimField(false, false)]
		public virtual ushort OemID
		{
			get
			{
					return ushort.Parse(this["OemID"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("OemID",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PingResponseEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePingResponseEnabled()
		{
			RemoveField("PingResponseEnabled");
		}

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

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT should respond to ping Echo Request messages.
		/// </summary>
		[CimField(false, false)]
		public virtual bool PingResponseEnabled
		{
			get
			{
				return bool.Parse(this["PingResponseEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("PingResponseEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PowerSource field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePowerSource()
		{
			RemoveField("PowerSource");
		}

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

		/// <summary>
		/// Optional, The system current power source
		/// </summary>
		[CimField(false, false)]
		public virtual uint PowerSource
		{
			get
			{
					return uint.Parse(this["PowerSource"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PowerSource",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PreferredAddressFamily field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePreferredAddressFamily()
		{
			RemoveField("PreferredAddressFamily");
		}

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

		/// <summary>
		/// Optional, Preferred Address Family (IPv4/IPv6).
		/// </summary>
		[CimField(false, false)]
		public virtual uint PreferredAddressFamily
		{
			get
			{
					return uint.Parse(this["PreferredAddressFamily"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PreferredAddressFamily",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PresenceNotificationInterval field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePresenceNotificationInterval()
		{
			RemoveField("PresenceNotificationInterval");
		}

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

		/// <summary>
		/// Optional, Defines the interval at which the FW will send periodic WS-management events notifications (for the subscribed clients) whenever network settings are changed. Units are minutes. A value of 0 disables periodic events. The default value for this property is 0 (notifications are disabled). The minimal allowed value is 15 minutes.
		/// </summary>
		[CimField(false, false)]
		public virtual uint PresenceNotificationInterval
		{
			get
			{
					return uint.Parse(this["PresenceNotificationInterval"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PresenceNotificationInterval",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PrivacyLevel field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePrivacyLevel()
		{
			RemoveField("PrivacyLevel");
		}

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

		/// <summary>
		/// Optional, Defines the Privacy Level setting.Privacy Level defines the values for privacy-related parameters by default and upon ME-unconfigure event.The setting can have the following values: 
		/// Default: 
		/// SOL enabled = true, IDER enabled = true, KVM enabled = true, Opt-in can be disabled =  true, opt-in configurable remotely = true. 
		/// Enhanced: 
		/// SOL enabled = true, IDER enabled = true, KVM enabled = true, Opt-in can be disabled =  false, opt-in configurable remotely = true. 
		/// Extreme:  
		/// SOL enabled = false, IDER enabled = false, KVM enabled = false, Opt-in can be disabled =  false, opt-in configurable remotely = false. 
		/// </summary>
		[CimField(false, false)]
		public virtual uint PrivacyLevel
		{
			get
			{
					return uint.Parse(this["PrivacyLevel"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PrivacyLevel",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove RmcpPingResponseEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRmcpPingResponseEnabled()
		{
			RemoveField("RmcpPingResponseEnabled");
		}

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

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT should respond to RMCP ping Echo Request messages.
		/// </summary>
		[CimField(false, false)]
		public virtual bool RmcpPingResponseEnabled
		{
			get
			{
				return bool.Parse(this["RmcpPingResponseEnabled"][0]);
			}
			set
			{
				this.SetOrAddField("RmcpPingResponseEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SharedFQDN field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSharedFQDN()
		{
			RemoveField("SharedFQDN");
		}

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

		/// <summary>
		/// Optional, Defines Whether the FQDN (HostName.DomainName) is shared with the Host or dedicated to ME. (The default value for this property is shared - TRUE).
		/// </summary>
		[CimField(false, false)]
		public virtual bool SharedFQDN
		{
			get
			{
				return bool.Parse(this["SharedFQDN"][0]);
			}
			set
			{
				this.SetOrAddField("SharedFQDN",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ThunderboltDockEnabled field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveThunderboltDockEnabled()
		{
			RemoveField("ThunderboltDockEnabled");
		}

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

		/// <summary>
		/// Optional, Indicates whether Thunderbolt dock solution is enabled
		/// </summary>
		[CimField(false, false)]
		public virtual uint ThunderboltDockEnabled
		{
			get
			{
					return uint.Parse(this["ThunderboltDockEnabled"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ThunderboltDockEnabled",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove WsmanOnlyMode field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveWsmanOnlyMode()
		{
			RemoveField("WsmanOnlyMode");
		}

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

		/// <summary>
		/// Optional, Indicates whether Intel(R) AMT should block network interfaces other than WS-Management.
		/// </summary>
		[CimField(false, false)]
		public virtual bool WsmanOnlyMode
		{
			get
			{
				return bool.Parse(this["WsmanOnlyMode"][0]);
			}
			set
			{
				this.SetOrAddField("WsmanOnlyMode",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		///AMT Authenticate provides authentication of AMT and binds TLS session to a specific device when AMT TLS Client certificate is not used.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_GeneralSettings", IsNullable=false)]
		private class AMTAuthenticate_INPUT : CimParams
		{
			public AMTAuthenticate_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Nonce created by user
			/// </summary>
			[CimField(false,true)]
			public virtual byte[] MC_Nonce
			{
				set
				{
				this.SetOrAddField("MC_Nonce",Convert.ToBase64String(value));
				}
			}
		}
		/// <summary>
		///AMT Authenticate provides authentication of AMT and binds TLS session to a specific device when AMT TLS Client certificate is not used.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_GeneralSettings", IsNullable=false)]
		private class AMTAuthenticate_OUTPUT : CimParams
		{
			public AMTAuthenticate_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, Nonce created by AMT FW
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] Nonce
			{
				get
				{
						return Convert.FromBase64String(this.GetField("Nonce")[0]);				}
			}
			/// <summary>
			/// Optional, 16 bytes containing the system UUID.
			/// </summary>
			[CimField(false,false)]
			public virtual string UUID
			{
				get
				{
					return this.GetField("UUID")[0];
				}
			}
			/// <summary>
			/// Optional, The system name configured when AMT is provisioned. Null terminated. Null for unprovisioned system
			/// </summary>
			[CimField(false,false)]
			public virtual string FQDN
			{
				get
				{
					return this.GetField("FQDN")[0];
				}
			}
			/// <summary>
			/// Optional, FW version of the system
			/// </summary>
			[CimField(false,false)]
			public virtual string FWVersion
			{
				get
				{
					return this.GetField("FWVersion")[0];
				}
			}
			/// <summary>
			/// Optional, The SVN of AMT app
			/// </summary>
			[CimField(false,false)]
			public virtual uint AMTSVN
			{
				get
				{
						return uint.Parse(this["AMTSVN"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Signature mechanism used for the hash and signing. Only value currently is 0 which is actually TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
			/// </summary>
			[CimField(false,false)]
			public virtual uint SignatureMechanism
			{
				get
				{
						return uint.Parse(this["SignatureMechanism"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Signature over Hash(Hash(AMT TLS Server Cert/ CIRA MPS Cert) || MCNonce || Nonce || FQDN || UUID || FWVersion || AMTSVN || DigestRealm || SignatureMechanism). 
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] Signature
			{
				get
				{
						return Convert.FromBase64String(this.GetField("Signature")[0]);				}
			}
			/// <summary>
			/// Optional, An array containing the lengths of the certificates which are stored in the certificates field in sequence, one after the other.&lt;/
			/// </summary>
			[CimField(false,false)]
			public virtual ushort[] LengthOfCertificates
			{
				get
				{
					string[] arr = this["LengthOfCertificates"];
					List<ushort> newArr = new List<ushort>();
					foreach (string str in arr)
					{
						newArr.Add(ushort.Parse(str, CultureInfo.InvariantCulture));
					}
					return newArr.ToArray();
				}
			}
			/// <summary>
			/// Optional, The On Die CA certificate chain used for signing the TLS Cert
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] Certificates
			{
				get
				{
						return Convert.FromBase64String(this.GetField("Certificates")[0]);				}
			}
		}
		/// <summary>
		///AMT Authenticate provides authentication of AMT and binds TLS session to a specific device when AMT TLS Client certificate is not used.
		/// </summary>
		/// <param name="inMC_Nonce">Required, IN -Nonce created by user</param>
		/// <param name="outNonce">OUT - Nonce created by AMT FW</param>
		/// <param name="outUUID">OUT - 16 bytes containing the system UUID.</param>
		/// <param name="outFQDN">OUT - The system name configured when AMT is provisioned. Null terminated. Null for unprovisioned system</param>
		/// <param name="outFWVersion">OUT - FW version of the system</param>
		/// <param name="outAMTSVN">OUT - The SVN of AMT app</param>
		/// <param name="outSignatureMechanism">OUT - Signature mechanism used for the hash and signing. Only value currently is 0 which is actually TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384</param>
		/// <param name="outSignature">OUT - Signature over Hash(Hash(AMT TLS Server Cert/ CIRA MPS Cert) || MCNonce || Nonce || FQDN || UUID || FWVersion || AMTSVN || DigestRealm || SignatureMechanism). </param>
		/// <param name="outLengthOfCertificates">OUT - An array containing the lengths of the certificates which are stored in the certificates field in sequence, one after the other.&lt;/</param>
		/// <param name="outCertificates">OUT - The On Die CA certificate chain used for signing the TLS Cert</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// </returns>
		public virtual uint AMTAuthenticate(byte[] inMC_Nonce,out byte[] outNonce,out string outUUID,out string outFQDN,out string outFWVersion,out uint outAMTSVN,out uint outSignatureMechanism,out byte[] outSignature,out ushort[] outLengthOfCertificates,out byte[] outCertificates)
		{
			AMTAuthenticate_INPUT input = new AMTAuthenticate_INPUT(this.XmlNamespace);
			if (inMC_Nonce != null)
				input.MC_Nonce=inMC_Nonce;
			AMTAuthenticate_OUTPUT output = new AMTAuthenticate_OUTPUT();
			uint returnValue = base.Invoke("AMTAuthenticate",input,out output);
			outNonce=null;
			outUUID=null;
			outFQDN=null;
			outFWVersion=null;
			outAMTSVN=0;
			outSignatureMechanism=0;
			outSignature=null;
			outLengthOfCertificates=null;
			outCertificates=null;
			if (returnValue == 0)
			{
				if (output.ContainsField("Nonce"))
					outNonce = output.Nonce;
				if (output.ContainsField("UUID"))
					outUUID = output.UUID;
				if (output.ContainsField("FQDN"))
					outFQDN = output.FQDN;
				if (output.ContainsField("FWVersion"))
					outFWVersion = output.FWVersion;
				if (output.ContainsField("AMTSVN"))
					outAMTSVN = output.AMTSVN;
				if (output.ContainsField("SignatureMechanism"))
					outSignatureMechanism = output.SignatureMechanism;
				if (output.ContainsField("Signature"))
					outSignature = output.Signature;
				if (output.ContainsField("LengthOfCertificates"))
					outLengthOfCertificates = output.LengthOfCertificates;
				if (output.ContainsField("Certificates"))
					outCertificates = output.Certificates;
			}
			return returnValue;
		}

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

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


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


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

		public new class CimKeys : CIM_SettingData.CimKeys
		{
			/// <summary>
			/// Key, Required, Within the scope of the instantiating Namespace, InstanceID opaquely and uniquely identifies an instance of this class.
			/// </summary>

			public virtual string InstanceID
			{
				get
				{
					return GetKey("InstanceID");
				}
				set
				{
					SetOrAddKey("InstanceID", value);
				}
			}
		}

	}
}