//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_WiFiEndpointSettings.cs
//
//  Contents:   CIM_WiFiEndpointSettings describes setting data that can be applied to an instance of CIM_WiFiEndpoint to enable it to associate to a particular Wi-Fi network.
//              This file was automatically generated from CIM_WiFiEndpointSettings.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>
	///CIM_WiFiEndpointSettings describes setting data that can be applied to an instance of CIM_WiFiEndpoint to enable it to associate to a particular Wi-Fi network.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_WiFiEndpointSettings")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_WiFiEndpointSettings", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_WiFiEndpointSettings", IsNullable=false)]
	public class CIM_WiFiEndpointSettings : CIM_SettingData
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_WiFiEndpointSettings() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_WiFiEndpointSettings(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 CIM_WiFiEndpointSettings(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AuthenticationMethod field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAuthenticationMethod()
		{
			RemoveField("AuthenticationMethod");
		}

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

		/// <summary>
		/// Optional, AuthenticationMethod shall specify the 802.11 authentication method used when the settings are applied. 	* Other (1): shall indicate that the desired authentication method is not specified in the list below. If AuthenticationMethod contains 1, OtherAuthenticationMethod should not be NULL and should not be empty.
		/// 	* Open System (2): shall indicate that the desired authentication method is Open System. AuthenticationMethod should contain 2 only if EncryptionMethod contains 2 ("WEP") or 5 ("None").
		/// 	* Shared Key (3): shall indicate that the desired authentication method is Shared Key. AuthenticationMethod should contain 3 only if EncryptionMethod contains 2 ("WEP") or 5 ("None").
		/// 	* WPA PSK (4): shall indicate that the desired authentication method is WPA (Wi-Fi Protected Access) PSK (Pre-Shared Key). AuthenticationMethod should contain 4 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA IEEE 802.1x (5): shall indicate that the desired authentication method is WPA (Wi-Fi Protected Access) IEEE 802.1x. AuthenticationMethod should contain 5 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA2 PSK (6): shall indicate that the desired authentication method is WPA2 (Wi-Fi Protected Access Version 2) PSK (Pre-Shared Key). AuthenticationMethod should containt 6 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA2 IEEE 802.1x (7): shall indicated that the desired authentication method is WPA2 (Wi-Fi Protected Access Version 2) IEEE 802.1x. AuthenticationMethod should contain 7 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA3 SAE IEEE 802.1x (32768): shall indicate that WPA3 (Wi-Fi Protected Access Version 3) SAE IEEE 802.1x authentication is supported. SupportedAuthenticationMethods shall contain 32768 only if SupportedEncryptionMethods contains 4 ("CCMP").
		/// 	* WPA3 OWE IEEE 802.1x (32769): shall indicate that WPA3 (Wi-Fi Protected Access Version 3) OWE (Opportunistic Wireless Encryption) IEEE 802.1x authentication is supported. SupportedAuthenticationMethods shall contain 32769 only if SupportedEncryptionMethods contains 4 ("CCMP")
		/// </summary>
		[CimField(false, false)]
		public virtual ushort AuthenticationMethod
		{
			get
			{
					return ushort.Parse(this["AuthenticationMethod"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AuthenticationMethod",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BSSType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBSSType()
		{
			RemoveField("BSSType");
		}

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

		/// <summary>
		/// Optional, BSSType shall indicate the Basic Service Set (BSS) Type that shall be used when the settings are applied. A Basic Service Set is a set of stations controlled by a single coordination function.
		/// 	* Independent: the WiFiEndpoint is associated directly to another client station.
		/// 	* Infrastructure: the WiFiEndpoint is associated to a network via an access point.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort BSSType
		{
			get
			{
					return ushort.Parse(this["BSSType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("BSSType",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EncryptionMethod field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEncryptionMethod()
		{
			RemoveField("EncryptionMethod");
		}

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

		/// <summary>
		/// Optional, EncryptionMethod shall specify the 802.11 encryption method used when the settings are applied. 	* Other (1): shall indicate that the desired encryption method is not specified in the list below. If this value is used, OtherEncryptionMethod should not be NULL and should not be empty.
		/// 	* WEP (2): shall indicate that the desired encryption method is Wired Equivalency Privacy (WEP). This value should be used only if AuthenticationMethod contains 2 ("Open System") or 3 ("Shared Key").
		/// 	* TKIP (3): shall indicate that the desired encryption method is Temporal Key Integrity Protocol (TKIP). This value should be used only if AuthenticationMethod contains 4 ("WPA PSK"), 5 ("WPA IEEE 802.1x"), 6 ("WPA2 PSK"), or 7 ("WPA2 IEEE 802.1x").
		/// 	* CCMP (4): shall indicate that the desired encryption method is Counter Mode with Cipher Block Chaining Message Authentication Code Protocol (CCMP). This value should be used only if AuthenticationMethod contains 4 ("WPA PSK"), 5 ("WPA IEEE 802.1x"), 6 ("WPA2 PSK"), or 7 ("WPA2 IEEE 802.1x").
		/// 	* None (5): shall indicate that no encryption is desired. This value should be used only if AuthenticationMethod contains 2 ("Open System") or 3 ("Shared Key").
		/// 	* GCMP 256 (32768): shall indicate that the desired encryption method is GCMP. This value should be used only if AuthenticationMethod contains 6 ("WPA2 PSK"), 7 ("WPA2 IEEE 802.1x") or 32768 ("WPA3 SAE").
		/// </summary>
		[CimField(false, false)]
		public virtual ushort EncryptionMethod
		{
			get
			{
					return ushort.Parse(this["EncryptionMethod"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EncryptionMethod",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove KeyIndex field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveKeyIndex()
		{
			RemoveField("KeyIndex");
		}

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

		/// <summary>
		/// Optional, KeyIndex shall contain the index of the active key in the Keys array property. KeyIndex should be non-NULL if and only Keys is non-NULL.
		/// </summary>
		[CimField(false, false)]
		public virtual byte KeyIndex
		{
			get
			{
					return byte.Parse(this["KeyIndex"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("KeyIndex",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Keys field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveKeys()
		{
			RemoveField("Keys");
		}

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

		/// <summary>
		/// Optional, Keys shall contain the default WEP encryption keys. Keys should be non-NULL if and only if EncryptionMethod contains 2 ("WEP").
		/// </summary>
		[CimField(false, false)]
		public virtual string[] Keys
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["Keys"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("Keys", arr);
			}
		}
		/// <summary>
		/// Remove OtherAuthenticationMethod field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherAuthenticationMethod()
		{
			RemoveField("OtherAuthenticationMethod");
		}

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

		/// <summary>
		/// Optional, OtherAuthenticationMethod shall specify the 802.11 authentication method used when the settings are applied if and only if AuthenticationMethod contains "Other". The format of this string shall be vendor-specific.
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherAuthenticationMethod
		{
			get
			{
				return this.GetField("OtherAuthenticationMethod")[0];
			}
			set
			{
			this.SetOrAddField("OtherAuthenticationMethod",value);
			}
		}
		/// <summary>
		/// Remove OtherEncryptionMethod field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherEncryptionMethod()
		{
			RemoveField("OtherEncryptionMethod");
		}

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

		/// <summary>
		/// Optional, OtherEncryptionMethod shall specify the 802.11 encryption method used when the settings are applied if and only if EncryptionMethod contains "Other". The format of this string shall be vendor-specific.
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherEncryptionMethod
		{
			get
			{
				return this.GetField("OtherEncryptionMethod")[0];
			}
			set
			{
			this.SetOrAddField("OtherEncryptionMethod",value);
			}
		}
		/// <summary>
		/// Remove PSKPassPhrase field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePSKPassPhrase()
		{
			RemoveField("PSKPassPhrase");
		}

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

		/// <summary>
		/// Optional, An ASCII alphanumeric string used to generate a PSK (pre-shared key). PSKPassPhrase and PSKValue should not both be non-NULL. PSKPassPhrase should be NULL if AuthenticationMethod does not contain 4 ("WPA PSK") or 6 ("WPA2 PSK").
		/// </summary>
		[CimField(false, false)]
		public virtual string PSKPassPhrase
		{
			get
			{
				return this.GetField("PSKPassPhrase")[0];
			}
			set
			{
			this.SetOrAddField("PSKPassPhrase",value);
			}
		}
		/// <summary>
		/// Remove PSKValue field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePSKValue()
		{
			RemoveField("PSKValue");
		}

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

		/// <summary>
		/// Optional, The actual binary value of a PSK (pre-shared key). PSKValue and PSKPassPhrase should not both be non-NULL. PSKValue should be NULL if AuthenticationMethod does not contain 4 ("WPA PSK") or 6 ("WPA2 PSK").
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] PSKValue
		{
			get
			{
					return Convert.FromBase64String(this.GetField("PSKValue")[0]);			}
			set
			{
			this.SetOrAddField("PSKValue",Convert.ToBase64String(value));
			}
		}
		/// <summary>
		/// Remove Priority field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePriority()
		{
			RemoveField("Priority");
		}

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

		/// <summary>
		/// Optional, Priority shall indicate the priority of the instance among all WiFiEndpointSettings instances.
		/// </summary>
		[CimField(false, false)]
		public virtual byte Priority
		{
			get
			{
					return byte.Parse(this["Priority"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Priority",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SSID field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSSID()
		{
			RemoveField("SSID");
		}

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

		/// <summary>
		/// Optional, SSID shall indicate the Service Set Identifier (SSID) that shall be used when the settings are applied to a WiFiEndpoint. An SSID identifies a wireless network.
		/// </summary>
		[CimField(false, false)]
		public virtual string SSID
		{
			get
			{
				return this.GetField("SSID")[0];
			}
			set
			{
			this.SetOrAddField("SSID",value);
			}
		}

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

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


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


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

		public new class CimKeys : CIM_SettingData.CimKeys
		{
		}

	}
}