//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_IEEE8021xSettings.cs
//
//  Contents:   IEEE8021xSettings specifies a set of IEEE 802.1x Port-Based Network Access Control settings that can be applied to a ISO OSI layer 2 ProtocolEndpoint.
//              This file was automatically generated from CIM_IEEE8021xSettings.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>
	///IEEE8021xSettings specifies a set of IEEE 802.1x Port-Based Network Access Control settings that can be applied to a ISO OSI layer 2 ProtocolEndpoint.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_IEEE8021xSettings")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_IEEE8021xSettings", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_IEEE8021xSettings", IsNullable=false)]
	public class CIM_IEEE8021xSettings : CIM_SettingData
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_IEEE8021xSettings() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_IEEE8021xSettings(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_IEEE8021xSettings(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AuthenticationProtocol field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAuthenticationProtocol()
		{
			RemoveField("AuthenticationProtocol");
		}

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

		/// <summary>
		/// Optional, AuthenticationProtocol shall indicate the desired EAP (Extensible Authentication Protocol) type.
		/// 	* EAP-TLS (0): shall indicate that the desired EAP type is the Transport Layer Security EAP type specified in RFC 2716. If AuthenticationProtocol contains 0, Username should not be null, ServerCertificateName and ServerCertificateNameComparison may be null or not null, and RoamingIdentity, Password, Domain, ProtectedAccessCredential, PACPassword, and PSK should be null.
		/// 	* EAP-TTLS/MSCHAPv2 (1): shall indicate that the desired EAP type is 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. If AuthenticationProtocol contains 1, Username and Password should not be null, RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, and Domain may be null or not null, and ProtectedAccessCredential, PACPassword, and PSK should be null.
		/// 	* PEAPv0/EAP-MSCHAPv2 (2): shall indicate that the desired EAP type is 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. If AuthenticationProtocol contains2, Username and Password should not be null, RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, and Domain may be null or not null, and ProtectedAccessCredential, PACPassword, and PSK should be null.
		/// 	* PEAPv1/EAP-GTC (3): shall indicate that the desired EAP type is 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. If AuthenticationProtocol contains 3, Username and Password should not be null, RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, and Domain may be null or not null, and ProtectedAccessCredential, PACPassword, and PSK should be null.
		/// 	* EAP-FAST/MSCHAPv2 (4): shall indicate that the desired EAP type is 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. If AuthenticationProtocol contains 4, Username and Password should not be null, RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, Domain, ProtectedAccessCredential, and PACPassword may be null or not null, and PSK should be null.
		/// 	* EAP-FAST/GTC (5): shall indicate that the desired EAP type is the Flexible Authentication Extensible Authentication Protocol EAP type specified in IETF RFC 4851, with Generic Token Card (GTC) as the inner authentication method. If AuthenticationProtocol contains 5, Username and Password should not be null, RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, Domain, ProtectedAccessCredential, and PACPassword may be null or not null, and PSK should be null.
		/// 	* EAP-MD5 (6): shall indicate that the desired EAP type is the EAP MD5 authentication method, specified in RFC 3748. If AuthenticationProtocol contains 6, Username and Password should not be null, Domain may be null or not null, and RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, ProtectedAccessCredential, PACPassword, and PSK should be null.
		/// 	* EAP-PSK (7): shall indicate that the desired EAP type is the EAP-PSK (Pre-Shared Key) EAP type specified in RFC 4764. If AuthenticationProtocol contains 7, Username and PSK should not be null, Domain and RoamingIdentity may be null or not null, and Password, ServerCertificateName, ServerCertificateNameComparison, ProtectedAccessCredential, and PACPassword should be null.
		/// 	* EAP-SIM (8): shall indicate that the desired EAP type is the Extensible Authentication Protocol Method for Global System for Mobile Communications (GSM) Subscriber Identity Modules (EAP-SIM), specified in RFC 4186. If AuthenticationProtocol contains 8, Username and PSK should not be null, Domain and RoamingIdentity may be null or not null, and Password, ServerCertificateName, ServerCertificateNameComparison, ProtectedAccessCredential, and PACPassword should be null.
		/// 	* EAP-AKA (9): shall indicate that the desired EAP type is the EAP Method for 3rd Generation Authentication and Key Agreement (EAP-AKA), specified in RFC 4187. If AuthenticationProtocol contains 9, Username and PSK should not be null, Domain and RoamingIdentity may be null or not null, and Password, ServerCertificateName, ServerCertificateNameComparison, ProtectedAccessCredential, and PACPassword should be null.
		/// 	* EAP-FAST/TLS (10): shall indicate that the desired EAP type is the Flexible Authentication EAP type specified in IETF RFC 4851, with TLS as the inner authentication method. If AuthenticationProtocol contains 10, Username and Password should not be null, RoamingIdentity, ServerCertificateName, ServerCertificateNameComparison, Domain, ProtectedAccessCredential, and PACPassword may be null or not null, and PSK should be null.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort AuthenticationProtocol
		{
			get
			{
					return ushort.Parse(this["AuthenticationProtocol"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AuthenticationProtocol",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Domain field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDomain()
		{
			RemoveField("Domain");
		}

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

		/// <summary>
		/// Optional, The domain (also known as realm) within which Username is unique.
		/// </summary>
		[CimField(false, false)]
		public virtual string Domain
		{
			get
			{
				return this.GetField("Domain")[0];
			}
			set
			{
			this.SetOrAddField("Domain",value);
			}
		}
		/// <summary>
		/// Remove PACPassword field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePACPassword()
		{
			RemoveField("PACPassword");
		}

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

		/// <summary>
		/// Optional, Optional password to extract the PAC (Protected Access Credential) information from the PAC data.
		/// </summary>
		[CimField(false, false)]
		public virtual string PACPassword
		{
			get
			{
				return this.GetField("PACPassword")[0];
			}
			set
			{
			this.SetOrAddField("PACPassword",value);
			}
		}
		/// <summary>
		/// Remove PSK field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePSK()
		{
			RemoveField("PSK");
		}

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

		/// <summary>
		/// Optional, A pre-shared key used for pre-shared key EAP types such as EAP-PSK, EAP-SIM, and EAP-AKA.
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] PSK
		{
			get
			{
					return Convert.FromBase64String(this.GetField("PSK")[0]);			}
			set
			{
			this.SetOrAddField("PSK",Convert.ToBase64String(value));
			}
		}
		/// <summary>
		/// Remove Password field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePassword()
		{
			RemoveField("Password");
		}

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

		/// <summary>
		/// Optional, A password associated with the user identified by Username within Domain.
		/// </summary>
		[CimField(false, false)]
		public virtual string Password
		{
			get
			{
				return this.GetField("Password")[0];
			}
			set
			{
			this.SetOrAddField("Password",value);
			}
		}
		/// <summary>
		/// Remove ProtectedAccessCredential field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveProtectedAccessCredential()
		{
			RemoveField("ProtectedAccessCredential");
		}

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

		/// <summary>
		/// Optional, A credential used by the supplicant and AAA server to establish a mutually authenticated encrypted tunnel for confidential user authentication.
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] ProtectedAccessCredential
		{
			get
			{
					return Convert.FromBase64String(this.GetField("ProtectedAccessCredential")[0]);			}
			set
			{
			this.SetOrAddField("ProtectedAccessCredential",Convert.ToBase64String(value));
			}
		}
		/// <summary>
		/// Remove RoamingIdentity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRoamingIdentity()
		{
			RemoveField("RoamingIdentity");
		}

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

		/// <summary>
		/// Optional, A string presented to the authentication server in 802.1x protocol exchange. The AAA server determines the format of this string. Formats supported by AAA servers include: &lt;domain&gt;\&lt;username&gt;, &lt;username&gt;@&lt;domain&gt;.
		/// </summary>
		[CimField(false, false)]
		public virtual string RoamingIdentity
		{
			get
			{
				return this.GetField("RoamingIdentity")[0];
			}
			set
			{
			this.SetOrAddField("RoamingIdentity",value);
			}
		}
		/// <summary>
		/// Remove ServerCertificateName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveServerCertificateName()
		{
			RemoveField("ServerCertificateName");
		}

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

		/// <summary>
		/// Optional, The name that shall be compared against the subject name field in the certificate provided by the AAA server. Shall contain either the fully qualified domain name of the AAA server, in which case ServerCertificateNameComparison shall contain "FullName", or the domain suffix of the AAA server, in which case ServerCertificateNameComparison shall contain "DomainSuffix".
		/// </summary>
		[CimField(false, false)]
		public virtual string ServerCertificateName
		{
			get
			{
				return this.GetField("ServerCertificateName")[0];
			}
			set
			{
			this.SetOrAddField("ServerCertificateName",value);
			}
		}
		/// <summary>
		/// Remove ServerCertificateNameComparison field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveServerCertificateNameComparison()
		{
			RemoveField("ServerCertificateNameComparison");
		}

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

		/// <summary>
		/// Optional, The comparison algorithm that shall be used by the server to validate the subject name field of the certificate presented by the AAA server against the value of the ServerCertificateName property.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ServerCertificateNameComparison
		{
			get
			{
					return ushort.Parse(this["ServerCertificateNameComparison"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ServerCertificateNameComparison",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Username field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveUsername()
		{
			RemoveField("Username");
		}

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

		/// <summary>
		/// Optional, Identifies the user requesting access to the network.
		/// </summary>
		[CimField(false, false)]
		public virtual string Username
		{
			get
			{
				return this.GetField("Username")[0];
			}
			set
			{
			this.SetOrAddField("Username",value);
			}
		}

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

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


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


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

		public new class CimKeys : CIM_SettingData.CimKeys
		{
		}

	}
}