//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_WiFiEndpoint.cs
//
//  Contents:   A wireless communication endpoint which, when its associated interface device is associated with an IEEE 802.11 wireless LAN, may send and receive data frames.
//              This file was automatically generated from CIM_WiFiEndpoint.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>
	///A wireless communication endpoint which, when its associated interface device is associated with an IEEE 802.11 wireless LAN, may send and receive data frames.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_WiFiEndpoint")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_WiFiEndpoint", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_WiFiEndpoint", IsNullable=false)]
	public class CIM_WiFiEndpoint : CIM_LANEndpoint
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_WiFiEndpoint() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_WiFiEndpoint(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_WiFiEndpoint(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AccessPointAddress field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAccessPointAddress()
		{
			RemoveField("AccessPointAddress");
		}

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

		/// <summary>
		/// Optional, AccessPointAddress shall contain the MAC address of the access point with which the WiFiEndpoint is currently associated. If the WiFiEndpoint is not currently associated, then AccessPointAddress shall be NULL.The MAC address shall be formatted as twelve hexadecimal digits (for example, "010203040506"), with each pair representing one of the six octets of the MAC address in "canonical" bit order. (Therefore, the Group address bit is found in the low order bit of the first character of the string.)
		/// </summary>
		[CimField(false, false)]
		public virtual string AccessPointAddress
		{
			get
			{
				return this.GetField("AccessPointAddress")[0];
			}
			set
			{
			this.SetOrAddField("AccessPointAddress",value);
			}
		}
		/// <summary>
		/// Remove Associated field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAssociated()
		{
			RemoveField("Associated");
		}

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

		/// <summary>
		/// Optional, Associated shall indicate whether or not the WiFiEndpoint is currently associated to an access point or client station.
		/// </summary>
		[CimField(false, false)]
		public virtual bool Associated
		{
			get
			{
				return bool.Parse(this["Associated"][0]);
			}
			set
			{
				this.SetOrAddField("Associated",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <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 method used to authenticate the WiFiEndpoint and the network to one another.
		/// 	* Unknown (0): shall indicate that the authentication method is unknown to the server.	* Other (1): shall indicate that the authentication method is known to the server but not specified in the list below. If AuthenticationMethod contains 1, OtherAuthenticationMethod shall not be NULL and shall not be empty.
		/// 	* Open System (2): shall indicate that the authentication method is Open System. AuthenticationMethod shall contain 2 only if EncryptionMethod contains 2 ("WEP").
		/// 	* Shared Key (3): shall indicate that the authentication method is Shared Key. AuthenticationMethod shall contain 3 only if EncryptionMethod contains 2 ("WEP").
		/// 	* WPA PSK (4): shall indicate that the authentication method is WPA (Wi-Fi Protected Access) PSK (Pre-Shared Key). AuthenticationMethod shall contain 4 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA IEEE 802.1x (5): shall indicate that the authentication method is WPA (Wi-Fi Protected Access) IEEE 802.1x. AuthenticationMethod shall contain 5 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA2 PSK (6): shall indicate that the authentication method is WPA2 (Wi-Fi Protected Access Version 2) PSK (Pre-Shared Key). AuthenticationMethod shall contain 6 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* WPA2 IEEE 802.1x (7): shall indicate that the authentication method is WPA2 (Wi-Fi Protected Access Version 2) IEEE 802.1x. AuthenticationMethod shall contain 6 only if EncryptionMethod contains 3 ("TKIP") or 4 ("CCMP").
		/// 	* CCKM IEEE 802.1x (8): CCKM (Cisco Centralized Key Management with LEAP or EAP-FAST)
		/// </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 of the network that corresponds to the instance. 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 encryption method in use to protect the confidentiality of data sent and received by the WiFiEndpoint.
		/// 	* Unknown (0): shall indicate that the encryption method is unknown to the server.
		/// 	* Other (1): shall indicate that the encryption method is known to the server but not defined in the list below. If EncryptionMethod contains 1, OtherEncryptionMethod shall not be NULL and shall not be empty.
		/// 	* WEP (2): shall indicate that the encryption method is Wired Equivalency Privacy (WEP). The value of EncryptionMethod shall be 2 only if the value of AuthenticationMethod is 2 ("Open System") or 3 ("Shared Key").
		/// 	* TKIP (3): shall indicate that the encryption method is Temporal Key Integrity Protocol (TKIP). The value of EncryptionMethod shall be 3 only if the value of AuthenticationMethod is 4 ("WPA PSK"), 5 ("WPA IEEE 802.1x"), 6 ("WPA2 PSK"), or 7 ("WPA2 IEEE 802.1x").
		/// 	* CCMP (4): shall indicate that the encryption method is Counter Mode with Cipher Block Chaining Message Authentication Code Protocol (CCMP). The value of EncryptionMethod shall be 4 only if the value of AuthenticationMethod is 4 ("WPA PSK"), 5 ("WPA IEEE 802.1x"), 6 ("WPA2 PSK"), or 7 ("WPA2 IEEE 802.1x").
		/// 	* None (5): shall indicate that no encryption method is in use. The value of EncryptionMethod shall be 5 only if the value of AuthenticationMethod is 2 ("Open System") or 3 ("Shared Key").
		/// </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 IEEE8021xAuthenticationProtocol field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIEEE8021xAuthenticationProtocol()
		{
			RemoveField("IEEE8021xAuthenticationProtocol");
		}

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

		/// <summary>
		/// Optional, IEEE8021xAuthenticationProtocol shall contain the EAP (Extensible Authentication Protocol) type if and only if AuthenticationMethod contains "WPA IEEE 802.1x" or "WPA2 IEEE 802.1x" or "CCKM IEEE 802.1x"
		/// .	* EAP-TLS (0): shall indicate the Transport Layer Security EAP type specified in RFC 2716.
		/// 	* EAP-TTLS/MSCHAPv2 (1): shall indicate the Tunneled TLS Authentication Protocol EAP type (specified in draft-ietf-pppext-eap-ttls) with Microsoft PPP CHAP Extensions, Version 2 (MSCHAPv2) as the inner authentication method.
		/// 	* PEAPv0/EAP-MSCHAPv2 (2): shall indicate the Protected Extensible Authentication Protocol (PEAP) Version 0 EAP type (specified in draft-kamath-pppext-peapv0), with Microsoft PPP CHAP Extensions, Version 2 (MSCHAPv2) as the inner authentication method.
		/// 	* PEAPv1/EAP-GTC (3): shall indicate the Protected Extensible Authentication Protocol (PEAP) Version 1 EAP type (specified in draft-josefsson-pppext-eap-tls-eap), with Generic Token Card (GTC) as the inner authentication method.
		/// 	* EAP-FAST/MSCHAPv2 (4): shall indicate the Flexible Authentication Extensible Authentication Protocol EAP type specified in IETF RFC 4851, with Microsoft PPP CHAP Extensions, Version 2 (MSCHAPv2) as the inner authentication method.
		/// 	* EAP-FAST/GTC (5): shall indicate the Flexible Authentication Extensible Authentication Protocol EAP type specified in IETF RFC 4851, with Generic Token Card (GTC) as the inner authentication method.
		/// 	* EAP-MD5 (6): shall indicate the EAP MD5 authentication method, specified in RFC 3748.
		/// 	* EAP-PSK (7): shall indicate the EAP-PSK (Pre-shared Key) Protocol specified in RFC 4764.
		/// 	* EAP-SIM (8): shall indicate the Extensible Authentication Protocol Method for Global System for Mobile Communications (GSM) Subscriber Identity Modules (EAP-SIM), specified in RFC 4186.
		/// 	* EAP-AKA (9): shall indicate the Extensible Authentication Protocol Method for 3rd Generation Authentication and Key Agreement (EAP-AKA) authentication method, specified in RFC 4187.
		/// 	* EAP-FAST/TLS (10): shall indicate the Flexible Authentication Extensible Authentication Protocol EAP type specified in IETF RFC 4851, with TLS as the inner authentication method.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort IEEE8021xAuthenticationProtocol
		{
			get
			{
					return ushort.Parse(this["IEEE8021xAuthenticationProtocol"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("IEEE8021xAuthenticationProtocol",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove LANID field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemoveLANID()
		{
			RemoveField("LANID");
		}

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

		/// <summary>
		/// Optional, LANID shall contain the Service Set Identifier (SSID) of the wireless LAN with which the Endpoint is associated, or shall be NULL if the Endpoint is not currently associated or this information is not known.
		/// </summary>
		[CimField(false, false)]
		public override string LANID
		{
			get
			{
				return this.GetField("LANID")[0];
			}
			set
			{
			this.SetOrAddField("LANID",value);
			}
		}
		/// <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 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 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 ProtocolIFType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemoveProtocolIFType()
		{
			RemoveField("ProtocolIFType");
		}

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

		/// <summary>
		/// Optional, ProtocolIFType's enumeration is limited to Wi-Fi and reserved values for this subclass of ProtocolEndpoint.
		/// </summary>
		[CimField(false, false)]
		public override ushort ProtocolIFType
		{
			get
			{
					return ushort.Parse(this["ProtocolIFType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ProtocolIFType",value.ToString(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_LANEndpoint.CimKeys
		{
		}

	}
}