//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_AbstractIndicationSubscription.cs
//
//  Contents:   CIM_IndicationSubscription describes a flow of Indications. The flow is specified by the referenced Filter, and directed to the referenced destination or process in the Handler. Property values of the referenced CIM_IndicationFilter instance and CIM_ListenerDestination instance MAY significantly effect the definition of the subscription. E.g., a subscription associated with a "Transient" destination MAY be deleted when the destination terminates or is no longer available.
//              This file was automatically generated from CIM_AbstractIndicationSubscription.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_IndicationSubscription describes a flow of Indications. The flow is specified by the referenced Filter, and directed to the referenced destination or process in the Handler. Property values of the referenced CIM_IndicationFilter instance and CIM_ListenerDestination instance MAY significantly effect the definition of the subscription. E.g., a subscription associated with a "Transient" destination MAY be deleted when the destination terminates or is no longer available.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AbstractIndicationSubscription")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_AbstractIndicationSubscription", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AbstractIndicationSubscription", IsNullable=false)]
	public class CIM_AbstractIndicationSubscription : CimBase
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_AbstractIndicationSubscription() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_AbstractIndicationSubscription(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_AbstractIndicationSubscription(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove FailureTriggerTimeInterval field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveFailureTriggerTimeInterval()
		{
			RemoveField("FailureTriggerTimeInterval");
		}

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

		/// <summary>
		/// Optional, The FailureTriggerTimeInterval is used by the client to specify a recommended minimum delay before the OnFatalErrorPolicy is implemented.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong FailureTriggerTimeInterval
		{
			get
			{
					return ulong.Parse(this["FailureTriggerTimeInterval"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("FailureTriggerTimeInterval",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Key, Required, The Filter that defines the criteria and data of the possible Indications of this subscription.
		/// </summary>
		[CimField(true, false)]
		public virtual CimReference Filter
		{
			get
			{
				string innerXML = this.GetField("Filter")[0];
				CimReference epr = new CimReference("Filter", XmlNamespace, innerXML);
				return epr;
			}
			set
			{
				this.SetOrAddField("Filter",value.Serialize(false));
			}
		}


		/// <summary>
		/// Key, Required, The Handler addressing delivery of the possible Indications of this subscription.
		/// </summary>
		[CimField(true, false)]
		public virtual CimReference Handler
		{
			get
			{
				string innerXML = this.GetField("Handler")[0];
				CimReference epr = new CimReference("Handler", XmlNamespace, innerXML);
				return epr;
			}
			set
			{
				this.SetOrAddField("Handler",value.Serialize(false));
			}
		}
		/// <summary>
		/// Remove OnFatalErrorPolicy field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOnFatalErrorPolicy()
		{
			RemoveField("OnFatalErrorPolicy");
		}

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

		/// <summary>
		/// Optional, Defines the desired behavior for a subscription when a fatal error occurs in one of the Indication processing subcomponents (e.g., Indication processor, Indication or instance provider, or Indication handler) and the Indication cannot be successfully sent. Specifically, a failure implies that some aspect of Indication generation, processing or dispatch is no longer functioning and Indications may be lost. If the value of OnFatalErrorPolicy is 2 ("Ignore") or not set (NULL), the subscription MUST continue to be processed in a 'best effort' mode. This mode of operation can lead to unpredictable, and potentially misleading results, because Indications may be lost. If the value is 3 ("Disable"), the subscription MUST be disabled. With this policy, no new Indications will be generated or dispatched until the subscription is explicitly enabled. This is accomplished via the property, SubscriptionState. If the value is 4 ("Remove"), the subscription MUST be deleted. Selecting this policy has the same effect as issuing a DeleteInstance operation on this subscription instance.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort OnFatalErrorPolicy
		{
			get
			{
					return ushort.Parse(this["OnFatalErrorPolicy"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("OnFatalErrorPolicy",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OtherOnFatalErrorPolicy field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherOnFatalErrorPolicy()
		{
			RemoveField("OtherOnFatalErrorPolicy");
		}

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

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

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

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

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

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

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

		/// <summary>
		/// Optional, Defines the count property for the repeat notification policy calculation.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort RepeatNotificationCount
		{
			get
			{
					return ushort.Parse(this["RepeatNotificationCount"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("RepeatNotificationCount",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove RepeatNotificationGap field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRepeatNotificationGap()
		{
			RemoveField("RepeatNotificationGap");
		}

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

		/// <summary>
		/// Optional, Defines the gap interval for the repeat notification policy calculation.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong RepeatNotificationGap
		{
			get
			{
					return ulong.Parse(this["RepeatNotificationGap"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("RepeatNotificationGap",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove RepeatNotificationInterval field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRepeatNotificationInterval()
		{
			RemoveField("RepeatNotificationInterval");
		}

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

		/// <summary>
		/// Optional, Defines the time interval for the repeat notification policy calculation.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong RepeatNotificationInterval
		{
			get
			{
					return ulong.Parse(this["RepeatNotificationInterval"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("RepeatNotificationInterval",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove RepeatNotificationPolicy field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRepeatNotificationPolicy()
		{
			RemoveField("RepeatNotificationPolicy");
		}

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

		/// <summary>
		/// Optional, The RepeatNotificationPolicy property defines the desired behavior for handling Indications that report the occurrence of the same underlying event (e.g., the disk is still generating I/O errors and has not yet been repaired). The defined semantics for the RepeatNotificationCount, RepeatNotificationInterval, and RepeatNotificationGap properties depend on the value of RepeatNotificationPolicy, but values for these properties MUST be set if the property is defined for the selected policy. If the value of RepeatNotificationPolicy is 0 ("Unknown") or not set, no special processing for repeat Indications is defined by the subscription. The semantics associated with the handling of repeat Indications MAY be defined by the Indication processing subcomponents. If the value of RepeatNotificationPolicy is 2 ("None"), special processing of repeat Indications MUST NOT be performed. If the value is 3 ("Suppress") the first RepeatNotificationCount Indications, describing the same event, MUST be sent and all subsequent Indications for this event suppressed for the remainder of the time interval RepeatNotificationInterval. A new interval starts when the next Indication for this event is received. If the value of RepeatNotificationPolicy is 4 ("Delay") and an Indication is received, this Indication MUST be suppressed if, including this Indication, RepeatNoticationCount or fewer Indications for this event have been received during the prior time interval defined by RepeatNotificationInterval. If this Indication is the RepeatNotificationCount + 1 Indication, this Indication MUST be sent and all subsequent Indications for this event ignored until the RepeatNotificationGap has elapsed. A RepeatNotificationInterval MAY NOT overlap a RepeatNotificationGap time interval.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort RepeatNotificationPolicy
		{
			get
			{
					return ushort.Parse(this["RepeatNotificationPolicy"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("RepeatNotificationPolicy",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SubscriptionDuration field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSubscriptionDuration()
		{
			RemoveField("SubscriptionDuration");
		}

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

		/// <summary>
		/// Optional, SubscriptionDuration defines the desired length of the subscription. Indications generated after the duration of the subscription has exceeded SubscriptionDuration MUST NOT be sent. The duration of a subscription MAY be changed by modifying this property. An expired subscription MAY be deleted and MUST NOT be modified. If the value of SubscriptionDuration is not set, the subscription MUST be treated as having no expiration date.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong SubscriptionDuration
		{
			get
			{
					return ulong.Parse(this["SubscriptionDuration"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("SubscriptionDuration",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SubscriptionInfo field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSubscriptionInfo()
		{
			RemoveField("SubscriptionInfo");
		}

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

		/// <summary>
		/// Optional, Subscription identification information. May be used by the client or protocol to store subscription identification information.
		/// </summary>
		[CimField(false, false)]
		public virtual string SubscriptionInfo
		{
			get
			{
				return this.GetField("SubscriptionInfo")[0];
			}
			set
			{
			this.SetOrAddField("SubscriptionInfo",value);
			}
		}
		/// <summary>
		/// Remove SubscriptionStartTime field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSubscriptionStartTime()
		{
			RemoveField("SubscriptionStartTime");
		}

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

		/// <summary>
		/// Optional, SubscriptionStartTime is the time the subscription was started. The value of this property is computed based on the notion of date and time of the ManagedSystemElement running the Indication processing subcomponents.
		/// </summary>
		[CimField(false, false)]
		public virtual CimDateTime SubscriptionStartTime
		{
			get
			{
					return CimDateTime.Parse(this["SubscriptionStartTime"][0]);
			}
			set
			{
				this.SetOrAddField("SubscriptionStartTime",value.ToString());
			}
		}
		/// <summary>
		/// Remove SubscriptionState field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSubscriptionState()
		{
			RemoveField("SubscriptionState");
		}

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

		/// <summary>
		/// Optional, Indicates the current processing state of the subscription.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort SubscriptionState
		{
			get
			{
					return ushort.Parse(this["SubscriptionState"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("SubscriptionState",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SubscriptionTimeRemaining field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSubscriptionTimeRemaining()
		{
			RemoveField("SubscriptionTimeRemaining");
		}

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

		/// <summary>
		/// Optional, SubscriptionTimeRemaining is a computed value that provides a snapshot of the time remaining in the Subscription.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong SubscriptionTimeRemaining
		{
			get
			{
					return ulong.Parse(this["SubscriptionTimeRemaining"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("SubscriptionTimeRemaining",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove TimeOfLastStateChange field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTimeOfLastStateChange()
		{
			RemoveField("TimeOfLastStateChange");
		}

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

		/// <summary>
		/// Optional, Date and time of the last state change. This value is based on the notion of local date and time of the Managed System Element running the Indication processing subcomponents.
		/// </summary>
		[CimField(false, false)]
		public virtual CimDateTime TimeOfLastStateChange
		{
			get
			{
					return CimDateTime.Parse(this["TimeOfLastStateChange"][0]);
			}
			set
			{
				this.SetOrAddField("TimeOfLastStateChange",value.ToString());
			}
		}

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

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


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


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

		public new class CimKeys : CimBase.CimKeys
		{
			/// <summary>
			/// Key, Required, The Filter that defines the criteria and data of the possible Indications of this subscription.
			/// </summary>

			public virtual CimReference Filter
			{
				get
				{
					string innerXML = GetKey("Filter");
					CimReference epr = new CimReference("Filter", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AbstractIndicationSubscription", innerXML);
					return epr;
				}
				set
				{
					SetOrAddKey("Filter", value);
				}
			}
			/// <summary>
			/// Key, Required, The Handler addressing delivery of the possible Indications of this subscription.
			/// </summary>

			public virtual CimReference Handler
			{
				get
				{
					string innerXML = GetKey("Handler");
					CimReference epr = new CimReference("Handler", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AbstractIndicationSubscription", innerXML);
					return epr;
				}
				set
				{
					SetOrAddKey("Handler", value);
				}
			}
		}

	}
}