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

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

		/// <summary>
		/// Optional, This setting defines once TLS is enabled and configured whether non-secure EOI/WSMAN connections are still accepted by FW on ports 16992 and 623. If AcceptNonSecureConnections is set to TRUE then non-secure connections are still accepted. If set to FALSE then non-secure connections are rejected. This setting may be set per interface for the local and network interfaces.
		/// </summary>
		[CimField(false, false)]
		public virtual bool AcceptNonSecureConnections
		{
			get
			{
				return bool.Parse(this["AcceptNonSecureConnections"][0]);
			}
			set
			{
				this.SetOrAddField("AcceptNonSecureConnections",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, Administrator-settable property that determines whether or not TLS is used on the associated service access point.
		/// </summary>
		[CimField(false, true)]
		public virtual bool Enabled
		{
			get
			{
				return bool.Parse(this["Enabled"][0]);
			}
			set
			{
				this.SetOrAddField("Enabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove MutualAuthentication field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMutualAuthentication()
		{
			RemoveField("MutualAuthentication");
		}

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

		/// <summary>
		/// Optional, Adminstrator-settable property that determines whether or not mutual authentication is used at the TLS layer is used on the associated service access point. If False, then only the server authenticates itself at the TLS layer.
		/// </summary>
		[CimField(false, false)]
		public virtual bool MutualAuthentication
		{
			get
			{
				return bool.Parse(this["MutualAuthentication"][0]);
			}
			set
			{
				this.SetOrAddField("MutualAuthentication",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove NonSecureConnectionsSupported field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveNonSecureConnectionsSupported()
		{
			RemoveField("NonSecureConnectionsSupported");
		}

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

		/// <summary>
		/// Optional, This setting define whether a non secure - aka direct tcpis supported or not - not supported from RPL on.This setting is read only.
		/// </summary>
		[CimField(false, false)]
		public virtual bool NonSecureConnectionsSupported
		{
			get
			{
				return bool.Parse(this["NonSecureConnectionsSupported"][0]);
			}
			set
			{
				this.SetOrAddField("NonSecureConnectionsSupported",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove TrustedCN field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTrustedCN()
		{
			RemoveField("TrustedCN");
		}

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

		/// <summary>
		/// Optional, An array of strings, used to validate the CN subfield of the subject field in X.509 certificates presented to Intel(R) AMT in the TLS handshake. This value must comply with the requirements of RFC 1035.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] TrustedCN
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["TrustedCN"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("TrustedCN", arr);
			}
		}
		/// <summary>
		/// Remove X509IssuerName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveX509IssuerName()
		{
			RemoveField("X509IssuerName");
		}

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

		/// <summary>
		/// Optional, The Issuer Name field in the X.509 certificate.
		/// </summary>
		[CimField(false, false)]
		public virtual string X509IssuerName
		{
			get
			{
				return this.GetField("X509IssuerName")[0];
			}
			set
			{
			this.SetOrAddField("X509IssuerName",value);
			}
		}
		/// <summary>
		/// Remove X509SerialNumber field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveX509SerialNumber()
		{
			RemoveField("X509SerialNumber");
		}

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

		/// <summary>
		/// Optional, The Serial Numebr field in the X.509 certificate.
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] X509SerialNumber
		{
			get
			{
					return Convert.FromBase64String(this.GetField("X509SerialNumber")[0]);			}
			set
			{
			this.SetOrAddField("X509SerialNumber",Convert.ToBase64String(value));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_SettingData.CimKeys
		{
		}

	}
}