//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_Indication.cs
//
//  Contents:   CIM_Indication is the abstract root class for all notifications about changes in schema, objects and their data, and about events detected by providers and instrumentation. Subclasses represent specific types of notifications. 
//              
//              To receive an Indication, a consumer (or subscriber) must create an instance of CIM_IndicationFilter describing the criteria of the notification, an instance of CIM_ListenerDestination describing the delivery of the notification, and an instance of CIM_IndicationSubscription associating the Filter and Handler.
//              This file was automatically generated from CIM_Indication.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_Indication is the abstract root class for all notifications about changes in schema, objects and their data, and about events detected by providers and instrumentation. Subclasses represent specific types of notifications. 
	///To receive an Indication, a consumer (or subscriber) must create an instance of CIM_IndicationFilter describing the criteria of the notification, an instance of CIM_ListenerDestination describing the delivery of the notification, and an instance of CIM_IndicationSubscription associating the Filter and Handler.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Indication")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_Indication", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Indication", IsNullable=false)]
	public class CIM_Indication : CimBase
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_Indication() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_Indication(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_Indication(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove CorrelatedIndications field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveCorrelatedIndications()
		{
			RemoveField("CorrelatedIndications");
		}

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

		/// <summary>
		/// Optional, A list of IndicationIdentifiers whose notifications are correlated with (related to) this one.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] CorrelatedIndications
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["CorrelatedIndications"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("CorrelatedIndications", arr);
			}
		}
		/// <summary>
		/// Remove IndicationFilterName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIndicationFilterName()
		{
			RemoveField("IndicationFilterName");
		}

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

		/// <summary>
		/// Optional, An identifier for the indication filter that selects this indication and causes it to be sent. This property is to be filled out by the indication sending service. The value shall be correlatable with the Name property of the instance of CIM_IndicationFilter describing the criteria of the indication. The value of the IndicationFilterName should be formatted using the following algorithm: &lt; OrgID &gt; : &lt; LocalID &gt;, where &lt; OrgID &gt; and &lt; LocalID &gt; are separated by a colon (:) and &lt; OrgID &gt; shall include a copyrighted, trademarked, or otherwise unique name that is owned by the business entity that is creating or defining the value or that is a registered ID assigned to the business entity by a recognized global authority. In addition, to ensure uniqueness, &lt; OrgID &gt; shall not contain a colon (:).When using this algorithm, the first colon to appear in the value shall appear between &lt; OrgID &gt; and &lt; LocalID &gt;. &lt; LocalID &gt; is chosen by the business entity and shall be used uniquely.
		/// </summary>
		[CimField(false, false)]
		public virtual string IndicationFilterName
		{
			get
			{
				return this.GetField("IndicationFilterName")[0];
			}
			set
			{
			this.SetOrAddField("IndicationFilterName",value);
			}
		}
		/// <summary>
		/// Remove IndicationIdentifier field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIndicationIdentifier()
		{
			RemoveField("IndicationIdentifier");
		}

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

		/// <summary>
		/// Optional, An identifier for the Indication. This property is similar to a key value in that it can be used for identification, when correlating Indications (see the CorrelatedIndications array). Its value SHOULD be unique as long as correlations are reported, but MAY be reused or left NULL if no future Indications will reference it in their CorrelatedIndications array.To ensure uniqueness, the value of IndicationIdentifier should be constructed using the following "preferred" algorithm: 
		/// &lt;OrgID&gt;:&lt;LocalID&gt; 
		/// Where &lt;OrgID&gt; and &lt;LocalID&gt; are separated by a colon (:), and where &lt;OrgID&gt; must include a copyrighted, trademarked, or otherwise unique name that is owned by the business entity that is creating or defining the IndicationIdentifier or that is a recognized ID that is assigned to the business entity by a recognized global authority. (This requirement is similar to the &lt;Schema Name&gt;_&lt;Class Name&gt; structure of Schema class names.) In addition, to ensure uniqueness &lt;OrgID&gt; must not contain a colon (:). When using this algorithm, the first colon to appear in IndicationIdentifier must appear between &lt;OrgID&gt; and &lt;LocalID&gt;. 
		/// &lt;LocalID&gt; is chosen by the business entity and should not be re-used to identify different underlying (real-world) elements. 
		/// If the above "preferred" algorithm is not used, the defining entity should assure that the resulting IndicationIdentifier is not re-used across any IndicationIdentifiers that are produced by this or other providers for the NameSpace of this instance. 
		/// For DMTF-defined instances, the "preferred" algorithm should be used with the &lt;OrgID&gt; set to CIM.
		/// </summary>
		[CimField(false, false)]
		public virtual string IndicationIdentifier
		{
			get
			{
				return this.GetField("IndicationIdentifier")[0];
			}
			set
			{
			this.SetOrAddField("IndicationIdentifier",value);
			}
		}
		/// <summary>
		/// Remove IndicationTime field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIndicationTime()
		{
			RemoveField("IndicationTime");
		}

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

		/// <summary>
		/// Optional, The time and date of creation of the Indication. The property may be set to NULL if the entity creating the Indication is not capable of determining this information. Note that IndicationTime may be the same for two Indications that are generated in rapid succession.
		/// </summary>
		[CimField(false, false)]
		public virtual CimDateTime IndicationTime
		{
			get
			{
					return CimDateTime.Parse(this["IndicationTime"][0]);
			}
			set
			{
				this.SetOrAddField("IndicationTime",value.ToString());
			}
		}
		/// <summary>
		/// Remove OtherSeverity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherSeverity()
		{
			RemoveField("OtherSeverity");
		}

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

		/// <summary>
		/// Optional, Holds the value of the user defined severity value when 'PerceivedSeverity' is 1 ("Other").
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherSeverity
		{
			get
			{
				return this.GetField("OtherSeverity")[0];
			}
			set
			{
			this.SetOrAddField("OtherSeverity",value);
			}
		}
		/// <summary>
		/// Remove PerceivedSeverity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePerceivedSeverity()
		{
			RemoveField("PerceivedSeverity");
		}

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

		/// <summary>
		/// Optional, An enumerated value that describes the severity of the 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 Indication is purely informational or its severity is simply unknown.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort PerceivedSeverity
		{
			get
			{
					return ushort.Parse(this["PerceivedSeverity"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PerceivedSeverity",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SequenceContext field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSequenceContext()
		{
			RemoveField("SequenceContext");
		}

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

		/// <summary>
		/// Optional, The sequence context portion of a sequence identifier for the indication. The sequence number portion of the sequence identifier is provided by the SequenceNumber property. The combination of both property values represents the sequence identifier for the indication.
		/// The sequence identifier for the indication enables a CIM listener to identify duplicate indications when the CIM service attempts the delivery retry of indications, to reorder indications that arrive out-of-order, and to detect lost indications.
		/// If a CIM service does not support sequence identifiers for indications, this property shall be NULL.
		/// If a CIM service supports sequence identifiers for indications, this property shall be maintained by the CIM service for each registered listener destination, and its value shall uniquely identify the CIM service and the indication service within the CIM service such that restarts of the CIM service and deregistration of listener destinations to the CIM service cause the value to change, without reusing earlier values for a sufficiently long time.
		/// When retrying the delivery of an indication, this property shall have the same value as in the original delivery.
		/// To guarantee this uniqueness, the property value should be constructed using the following format (defined in ABNF): sequence-context = indication-service-name "#" cim-service-start-id "#" listener-destination-creation-time
		/// Where: indication-service-name is the value of the Name property of the CIM_IndicationService instance responsible for delivering the indication. cim-service-start-id is an identifier that uniquely identifies the CIM service start, for example via a timestamp of the start time, or via a counter that increases for each start or restart. listener-destination-creation-time is a timestamp of the creation time of the CIM_ListenerDestination instance representing the listener destination.
		/// Since this format is only a recommendation, CIM clients shall treat the value as an opaque identifier for the sequence context and shall not rely on this format.
		/// </summary>
		[CimField(false, false)]
		public virtual string SequenceContext
		{
			get
			{
				return this.GetField("SequenceContext")[0];
			}
			set
			{
			this.SetOrAddField("SequenceContext",value);
			}
		}
		/// <summary>
		/// Remove SequenceNumber field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSequenceNumber()
		{
			RemoveField("SequenceNumber");
		}

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

		/// <summary>
		/// Optional, The sequence number portion of a sequence identifier for the indication. The sequence context portion of the sequence identifier is provided by the SequenceContext property. The combination of both property values represents the sequence identifier for the indication.
		/// The sequence identifier for the indication enables a CIM listener to identify duplicate indications when the CIM service attempts the delivery retry of indications, to reorder indications that arrive out-of-order, and to detect lost indications.
		/// If a CIM service does not support sequence identifiers for indications, this property shall be NULL.
		/// If a CIM service supports sequence identifiers for indications, this property shall be maintained by the CIM service for each registered listener destination, and its value shall uniquely identify the indication within the sequence context provided by SequenceContext. It shall start at 0 whenever the sequence context string changes. Otherwise, it shall be increased by 1 for every new indication to that listener destination, and it shall wrap to 0 when the value range is exceeded.
		/// When retrying the delivery of an indication, this property shall have the same value as in the original delivery.
		/// </summary>
		[CimField(false, false)]
		public virtual long SequenceNumber
		{
			get
			{
					return long.Parse(this["SequenceNumber"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("SequenceNumber",value.ToString(CultureInfo.InvariantCulture));
			}
		}

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

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


		/// <summary>
		/// Delete the instance of CIM_Indication 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 void Delete(IWSManClient client)
		{
			CimBase.Delete<CIM_Indication>(client);
		}


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

		public new class CimKeys : CimBase.CimKeys
		{
		}

	}
}