//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_AlertIndication.cs
//
//  Contents:   A concrete superclass for CIM Alert notifications. An AlertIndication is a specialized type of CIM_Indication that contains information about the severity, cause, recommended actions and other data of a real world event. This event and its data may or may not be modeled in the CIM class hierarchy.
//              This file was automatically generated from CIM_AlertIndication.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 concrete superclass for CIM Alert notifications. An AlertIndication is a specialized type of CIM_Indication that contains information about the severity, cause, recommended actions and other data of a real world event. This event and its data may or may not be modeled in the CIM class hierarchy.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AlertIndication")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_AlertIndication", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AlertIndication", IsNullable=false)]
	public class CIM_AlertIndication : CIM_ProcessIndication
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_AlertIndication() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_AlertIndication(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_AlertIndication(IWSManClient client): base(client)
		{
		}


		/// <summary>
		/// Required, Primary classification of the Indication. The following values are defined: 
		/// 1 - Other. The Indication's OtherAlertType property conveys its classification. Use of "Other" in an enumeration is a standard CIM convention. It means that the current Indication does not fit into the categories described by this enumeration. 
		/// 2 - Communications Alert. An Indication of this type is principally associated with the procedures and/or processes required to convey information from one point to another. 
		/// 3 - Quality of Service Alert. An Indication of this type is principally associated with a degradation or errors in the performance or function of an entity. 
		/// 4 - Processing Error. An Indication of this type is principally associated with a software or processing fault. 
		/// 5 - Device Alert. An Indication of this type is principally associated with an equipment or hardware fault. 
		/// 6 - Environmental Alert. An Indication of this type is principally associated with a condition relating to an enclosure in which the hardware resides, or other environmental considerations. 
		/// 7 - Model Change. The Indication addresses changes in the Information Model. For example, it may embed a Lifecycle Indication to convey the specific model change being alerted. 
		/// 8 - Security Alert. An Indication of this type is associated with security violations, detection of viruses, and similar issues.
		/// </summary>
		[CimField(false, true)]
		public virtual ushort AlertType
		{
			get
			{
					return ushort.Parse(this["AlertType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AlertType",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove AlertingElementFormat field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAlertingElementFormat()
		{
			RemoveField("AlertingElementFormat");
		}

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

		/// <summary>
		/// Optional, The format of the AlertingManagedElement property is interpretable based upon the value of this property. Values are defined as: 
		/// 0 - Unknown. The format is unknown or not meaningfully interpretable by a CIM client application. 
		/// 1 - Other. The format is defined by the value of the OtherAlertingElementFormat property. 
		/// 2 - CIMObjectPath. The format is a CIMObjectPath, with format &lt;NamespacePath&gt;:&lt;ClassName&gt;.&lt;Prop1&gt;="&lt;Value1&gt;", &lt;Prop2&gt;="&lt;Value2&gt;", . . . specifying an instance in the CIM Schema.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort AlertingElementFormat
		{
			get
			{
					return ushort.Parse(this["AlertingElementFormat"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AlertingElementFormat",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove AlertingManagedElement field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAlertingManagedElement()
		{
			RemoveField("AlertingManagedElement");
		}

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

		/// <summary>
		/// Optional, The identifying information of the entity (ie, the instance) for which this Indication is generated. The property contains the path of an instance, encoded as a string parameter - if the instance is modeled in the CIM Schema. If not a CIM instance, the property contains some identifying string that names the entity for which the Alert is generated. The path or identifying string is formatted per the AlertingElementFormat property.
		/// </summary>
		[CimField(false, false)]
		public virtual string AlertingManagedElement
		{
			get
			{
				return this.GetField("AlertingManagedElement")[0];
			}
			set
			{
			this.SetOrAddField("AlertingManagedElement",value);
			}
		}
		/// <summary>
		/// Remove Description field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDescription()
		{
			RemoveField("Description");
		}

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

		/// <summary>
		/// Optional, A short description of the Indication.
		/// </summary>
		[CimField(false, false)]
		public virtual string Description
		{
			get
			{
				return this.GetField("Description")[0];
			}
			set
			{
			this.SetOrAddField("Description",value);
			}
		}
		/// <summary>
		/// Remove EventID field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventID()
		{
			RemoveField("EventID");
		}

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

		/// <summary>
		/// Optional, An instrumentation or provider specific value that describes the underlying "real-world" event represented by the Indication. Two Indications with the same, non NULL EventID value are considered, by the creating entity, to represent the same event. The comparison of two EventID values is only defined for Alert Indications with identical, non NULL values of SystemCreateClassName, SystemName and ProviderName.
		/// </summary>
		[CimField(false, false)]
		public virtual string EventID
		{
			get
			{
				return this.GetField("EventID")[0];
			}
			set
			{
			this.SetOrAddField("EventID",value);
			}
		}
		/// <summary>
		/// Remove EventTime field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventTime()
		{
			RemoveField("EventTime");
		}

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

		/// <summary>
		/// Optional, The time and date the underlying event was first detected. If specified, this property MUST be set to NULL if the creating entity is not capable of providing this information. This value is based on the notion of local date and time of the Managed System Element generating the Indication.
		/// </summary>
		[CimField(false, false)]
		public virtual CimDateTime EventTime
		{
			get
			{
					return CimDateTime.Parse(this["EventTime"][0]);
			}
			set
			{
				this.SetOrAddField("EventTime",value.ToString());
			}
		}
		/// <summary>
		/// Remove Message field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMessage()
		{
			RemoveField("Message");
		}

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

		/// <summary>
		/// Optional, The formatted message. This message is constructed by combining some or all of the dynamic elements specified in the MessageArguments property with the static elements uniquely identified by the MessageID in a message registry or other catalog associated with the OwningEntity.
		/// </summary>
		[CimField(false, false)]
		public virtual string Message
		{
			get
			{
				return this.GetField("Message")[0];
			}
			set
			{
			this.SetOrAddField("Message",value);
			}
		}
		/// <summary>
		/// Remove MessageArguments field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMessageArguments()
		{
			RemoveField("MessageArguments");
		}

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

		/// <summary>
		/// Optional, An array containing the dynamic content of the message.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] MessageArguments
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["MessageArguments"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("MessageArguments", arr);
			}
		}
		/// <summary>
		/// Remove MessageID field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMessageID()
		{
			RemoveField("MessageID");
		}

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

		/// <summary>
		/// Optional, A string that uniquely identifies, within the scope of the OwningEntity, the format of the Message.
		/// </summary>
		[CimField(false, false)]
		public virtual string MessageID
		{
			get
			{
				return this.GetField("MessageID")[0];
			}
			set
			{
			this.SetOrAddField("MessageID",value);
			}
		}
		/// <summary>
		/// Remove OtherAlertType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherAlertType()
		{
			RemoveField("OtherAlertType");
		}

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

		/// <summary>
		/// Optional, A string describing the Alert type - used when the AlertType property is set to 1, "Other State Change".
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherAlertType
		{
			get
			{
				return this.GetField("OtherAlertType")[0];
			}
			set
			{
			this.SetOrAddField("OtherAlertType",value);
			}
		}
		/// <summary>
		/// Remove OtherAlertingElementFormat field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherAlertingElementFormat()
		{
			RemoveField("OtherAlertingElementFormat");
		}

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

		/// <summary>
		/// Optional, A string defining "Other" values for AlertingElementFormat. This value MUST be set to a non NULL value when AlertingElementFormat is set to a value of 1 ("Other"). For all other values of AlertingElementFormat, the value of this string must be set to NULL.
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherAlertingElementFormat
		{
			get
			{
				return this.GetField("OtherAlertingElementFormat")[0];
			}
			set
			{
			this.SetOrAddField("OtherAlertingElementFormat",value);
			}
		}
		/// <summary>
		/// Remove OwningEntity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOwningEntity()
		{
			RemoveField("OwningEntity");
		}

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

		/// <summary>
		/// Optional, A string that uniquely identifies the entity that owns the definition of the format of the Message described in this instance. OwningEntity MUST include a copyrighted, trademarked or otherwise unique name that is owned by the business entity or standards body defining the format.
		/// </summary>
		[CimField(false, false)]
		public virtual string OwningEntity
		{
			get
			{
				return this.GetField("OwningEntity")[0];
			}
			set
			{
			this.SetOrAddField("OwningEntity",value);
			}
		}


		/// <summary>
		/// Required, An enumerated value that describes the severity of the Alert Indication from the notifier's point of view: 
		/// 1 - Other, by CIM convention, is used to indicate that the Severity's value can be found in the OtherSeverity property. 
		/// 3 - Degraded/Warning should be used when its appropriate to let the user decide if action is needed. 
		/// 4 - Minor should be used to indicate action is needed, but the situation is not serious at this time. 
		/// 5 - Major should be used to indicate action is needed NOW. 
		/// 6 - Critical should be used to indicate action is needed NOW and the scope is broad (perhaps an imminent outage to a critical resource will result). 
		/// 7 - Fatal/NonRecoverable should be used to indicate an error occurred, but it's too late to take remedial action. 
		/// 2 and 0 - Information and Unknown (respectively) follow common usage. Literally, the AlertIndication is purely informational or its severity is simply unknown.
		/// </summary>
		[CimField(false, true)]
		public override ushort PerceivedSeverity
		{
			get
			{
					return ushort.Parse(this["PerceivedSeverity"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PerceivedSeverity",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, An enumerated value that describes the probable cause of the situation which resulted in the AlertIndication.
		/// </summary>
		[CimField(false, true)]
		public virtual ushort ProbableCause
		{
			get
			{
					return ushort.Parse(this["ProbableCause"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ProbableCause",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ProbableCauseDescription field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveProbableCauseDescription()
		{
			RemoveField("ProbableCauseDescription");
		}

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

		/// <summary>
		/// Optional, Provides additional information related to the ProbableCause.
		/// </summary>
		[CimField(false, false)]
		public virtual string ProbableCauseDescription
		{
			get
			{
				return this.GetField("ProbableCauseDescription")[0];
			}
			set
			{
			this.SetOrAddField("ProbableCauseDescription",value);
			}
		}
		/// <summary>
		/// Remove ProviderName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveProviderName()
		{
			RemoveField("ProviderName");
		}

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

		/// <summary>
		/// Optional, The name of the Provider generating this Indication.
		/// </summary>
		[CimField(false, false)]
		public virtual string ProviderName
		{
			get
			{
				return this.GetField("ProviderName")[0];
			}
			set
			{
			this.SetOrAddField("ProviderName",value);
			}
		}
		/// <summary>
		/// Remove RecommendedActions field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRecommendedActions()
		{
			RemoveField("RecommendedActions");
		}

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

		/// <summary>
		/// Optional, Free form descriptions of the recommended actions to take to resolve the cause of the notification.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] RecommendedActions
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["RecommendedActions"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("RecommendedActions", arr);
			}
		}
		/// <summary>
		/// Remove SystemCreationClassName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSystemCreationClassName()
		{
			RemoveField("SystemCreationClassName");
		}

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

		/// <summary>
		/// Optional, The scoping System's CreationClassName for the Provider generating this Indication.
		/// </summary>
		[CimField(false, false)]
		public virtual string SystemCreationClassName
		{
			get
			{
				return this.GetField("SystemCreationClassName")[0];
			}
			set
			{
			this.SetOrAddField("SystemCreationClassName",value);
			}
		}
		/// <summary>
		/// Remove SystemName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSystemName()
		{
			RemoveField("SystemName");
		}

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

		/// <summary>
		/// Optional, The scoping System's Name for the Provider generating this Indication.
		/// </summary>
		[CimField(false, false)]
		public virtual string SystemName
		{
			get
			{
				return this.GetField("SystemName")[0];
			}
			set
			{
			this.SetOrAddField("SystemName",value);
			}
		}
		/// <summary>
		/// Remove Trending field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTrending()
		{
			RemoveField("Trending");
		}

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

		/// <summary>
		/// Optional, Provides information on trending - trending up, down or no change.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort Trending
		{
			get
			{
					return ushort.Parse(this["Trending"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Trending",value.ToString(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_ProcessIndication.CimKeys
		{
		}

	}
}