//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_EnvironmentDetectionSettingData.cs
//
//  Contents:   The AMT_EnvironmentDetectionSettingData class represents configuration-related and operational parameters for the Environment-Detection service in the Intel(R) AMT.
//              This file was automatically generated from AMT_EnvironmentDetectionSettingData.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_EnvironmentDetectionSettingData class represents configuration-related and operational parameters for the Environment-Detection service in the Intel(R) AMT.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EnvironmentDetectionSettingData")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_EnvironmentDetectionSettingData", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EnvironmentDetectionSettingData", IsNullable=false)]
	public class AMT_EnvironmentDetectionSettingData : CIM_SettingData
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_EnvironmentDetectionSettingData() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_EnvironmentDetectionSettingData(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_EnvironmentDetectionSettingData(IWSManClient client): base(client)
		{
		}


		/// <summary>
		/// Required, Specifies which algorithm is used to determine whether the system is in its intranet environment or in the Internet environment.
		/// </summary>
		[CimField(false, true)]
		public virtual ushort DetectionAlgorithm
		{
			get
			{
					return ushort.Parse(this["DetectionAlgorithm"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("DetectionAlgorithm",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DetectionIPv6LocalPrefixes field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDetectionIPv6LocalPrefixes()
		{
			RemoveField("DetectionIPv6LocalPrefixes");
		}

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

		/// <summary>
		/// Optional, Can be used for environment detection in IPv6 networks that do not configure the DNS suffix via DHCP. The format is: "XXXX:XXXX:XXXX:XXXX/Y" where Y is the prefix length, the XXXX:XXXX:XXXX:XXXX part can include zeros compression (e.g. 0:0:0 or ::) formats.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] DetectionIPv6LocalPrefixes
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["DetectionIPv6LocalPrefixes"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("DetectionIPv6LocalPrefixes", arr);
			}
		}
		/// <summary>
		/// Remove DetectionStrings field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDetectionStrings()
		{
			RemoveField("DetectionStrings");
		}

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

		/// <summary>
		/// Optional, An array of strings used in the environment detection algorithm. If DetectionAlgorithm is "Local Domains", DetectionStrings contains a set of local domain strings. If DetectionAlgorithm is "Remote URLs", then DetectionStrings contains a set of remote URLs.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] DetectionStrings
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["DetectionStrings"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("DetectionStrings", arr);
			}
		}
		/// <summary>
		///Defines the System Defense policy which will be used by Environment Detection and updates the appropriate instances of AMT_EnvironmentDetectionInterfacePolicy.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EnvironmentDetectionSettingData", IsNullable=false)]
		private class SetSystemDefensePolicy_INPUT : CimParams
		{
			public SetSystemDefensePolicy_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, The System Defense policy which will be applied to each interface separately when it is assumed that the interface is connected to an external network. When this parameter is Null, System Defense functionality is expected to remain the same when operating inside or outside the organization.
			/// </summary>
			[CimField(false,false)]
			public virtual CimReference Policy
			{
				set
				{
					this.SetOrAddField("Policy",value.Serialize(false));
				}
			}
		}
		/// <summary>
		///Defines the System Defense policy which will be used by Environment Detection and updates the appropriate instances of AMT_EnvironmentDetectionInterfacePolicy.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EnvironmentDetectionSettingData", IsNullable=false)]
		private class SetSystemDefensePolicy_OUTPUT : CimParams
		{
			public SetSystemDefensePolicy_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Defines the System Defense policy which will be used by Environment Detection and updates the appropriate instances of AMT_EnvironmentDetectionInterfacePolicy.
		/// </summary>
		/// <param name="inPolicy">Optional, IN -The System Defense policy which will be applied to each interface separately when it is assumed that the interface is connected to an external network. When this parameter is Null, System Defense functionality is expected to remain the same when operating inside or outside the organization.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// </returns>
		public virtual uint SetSystemDefensePolicy(CimReference inPolicy)
		{
			SetSystemDefensePolicy_INPUT input = new SetSystemDefensePolicy_INPUT(this.XmlNamespace);
			if (inPolicy != null)
				input.Policy=inPolicy;
			SetSystemDefensePolicy_OUTPUT output = new SetSystemDefensePolicy_OUTPUT();
			uint returnValue = base.Invoke("SetSystemDefensePolicy",input,out output);
			return returnValue;
		}
		/// <summary>
		///This command is used to enable or disable VPN routing of Intel(R) AMT network messages.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EnvironmentDetectionSettingData", IsNullable=false)]
		private class EnableVpnRouting_INPUT : CimParams
		{
			public EnableVpnRouting_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Enable or disable the VPN routing feature.
			/// </summary>
			[CimField(false,true)]
			public virtual bool Enable
			{
				set
				{
					this.SetOrAddField("Enable",value.ToString().ToLower(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///This command is used to enable or disable VPN routing of Intel(R) AMT network messages.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EnvironmentDetectionSettingData", IsNullable=false)]
		private class EnableVpnRouting_OUTPUT : CimParams
		{
			public EnableVpnRouting_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///This command is used to enable or disable VPN routing of Intel(R) AMT network messages.
		/// </summary>
		/// <param name="inEnable">Required, IN -Enable or disable the VPN routing feature.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// </returns>
		public virtual uint EnableVpnRouting(bool? inEnable)
		{
			EnableVpnRouting_INPUT input = new EnableVpnRouting_INPUT(this.XmlNamespace);
			if (inEnable.HasValue)
				input.Enable=inEnable.Value;
			EnableVpnRouting_OUTPUT output = new EnableVpnRouting_OUTPUT();
			uint returnValue = base.Invoke("EnableVpnRouting",input,out output);
			return returnValue;
		}

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

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


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


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

		public new class CimKeys : CIM_SettingData.CimKeys
		{
		}

	}
}