//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_Error.cs
//
//  Contents:   CIM_Error is a specialized class that contains information about the severity, cause, recommended actions and other data related to the failure of a CIM Operation. Instances of this type MAY be included as part of the response to a CIM Operation.
//              This file was automatically generated from CIM_Error.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_Error is a specialized class that contains information about the severity, cause, recommended actions and other data related to the failure of a CIM Operation. Instances of this type MAY be included as part of the response to a CIM Operation.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Error")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_Error", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Error", IsNullable=false)]
	public class CIM_Error : CimBase
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_Error() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_Error(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_Error(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove CIMStatusCode field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveCIMStatusCode()
		{
			RemoveField("CIMStatusCode");
		}

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

		/// <summary>
		/// Optional, The CIM status code that characterizes this instance. 
		/// This property defines the status codes that MAY be return by a conforming CIM Server or Listener. Note that not all status codes are valid for each operation. The specification for each operation SHOULD define the status codes that may be returned by that operation. 
		/// The following values for CIM status code are defined: 
		/// 1 - CIM_ERR_FAILED. A general error occurred that is not covered by a more specific error code. 
		/// 2 - CIM_ERR_ACCESS_DENIED. Access to a CIM resource was not available to the client. 
		/// 3 - CIM_ERR_INVALID_NAMESPACE. The target namespace does not exist. 
		/// 4 - CIM_ERR_INVALID_PARAMETER. One or more parameter values passed to the method were invalid. 
		/// 5 - CIM_ERR_INVALID_CLASS. The specified Class does not exist. 
		/// 6 - CIM_ERR_NOT_FOUND. The requested object could not be found. 
		/// 7 - CIM_ERR_NOT_SUPPORTED. The requested operation is not supported. 
		/// 8 - CIM_ERR_CLASS_HAS_CHILDREN. Operation cannot be carried out on this class since it has instances. 
		/// 9 - CIM_ERR_CLASS_HAS_INSTANCES. Operation cannot be carried out on this class since it has instances. 
		/// 10 - CIM_ERR_INVALID_SUPERCLASS. Operation cannot be carried out since the specified superclass does not exist. 
		/// 11 - CIM_ERR_ALREADY_EXISTS. Operation cannot be carried out because an object already exists. 
		/// 12 - CIM_ERR_NO_SUCH_PROPERTY. The specified Property does not exist. 
		/// 13 - CIM_ERR_TYPE_MISMATCH. The value supplied is incompatible with the type. 
		/// 14 - CIM_ERR_QUERY_LANGUAGE_NOT_SUPPORTED. The query language is not recognized or supported. 
		/// 15 - CIM_ERR_INVALID_QUERY. The query is not valid for the specified query language. 
		/// 16 - CIM_ERR_METHOD_NOT_AVAILABLE. The extrinsic Method could not be executed. 
		/// 17 - CIM_ERR_METHOD_NOT_FOUND. The specified extrinsic Method does not exist. 
		/// 18 - CIM_ERR_UNEXPECTED_RESPONSE. The returned response to the asynchronous operation was not expected. 
		/// 19 - CIM_ERR_INVALID_RESPONSE_DESTINATION. The specified destination for the asynchronous response is not valid. 
		/// 20 - CIM_ERR_NAMESPACE_NOT_EMPTY. The specified Namespace is not empty.
		/// 21 - CIM_ERR_INVALID_ENUMERATION_CONTEXT. The enumeration context supplied is not valid.
		/// 22 - CIM_ERR_INVALID_OPERATION_TIMEOUT. The specified Namespace is not empty.
		/// 23 - CIM_ERR_PULL_HAS_BEEN_ABANDONED. The specified Namespace is not empty.
		/// 24 - CIM_ERR_PULL_CANNOT_BE_ABANDONED. The attempt to abandon a pull operation has failed.
		/// 25 - CIM_ERR_FILTERED_ENUMERATION_NOT_SUPPORTED. Filtered Enumeratrions are not supported.
		/// 26 - CIM_ERR_CONTINUATION_ON_ERROR_NOT_SUPPORTED. Continue on error is not supported.
		/// 27 - CIM_ERR_SERVER_LIMITS_EXCEEDED. The WBEM Server limits have been exceeded (e.g. memory, connections, ...).
		/// 28 - CIM_ERR_SERVER_IS_SHUTTING_DOWN. The WBEM Server is shutting down.
		/// 29 - CIM_ERR_QUERY_FEATURE_NOT_SUPPORTED. The specified Query Feature is not supported.
		/// </summary>
		[CimField(false, false)]
		public virtual uint CIMStatusCode
		{
			get
			{
					return uint.Parse(this["CIMStatusCode"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("CIMStatusCode",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove CIMStatusCodeDescription field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveCIMStatusCodeDescription()
		{
			RemoveField("CIMStatusCodeDescription");
		}

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

		/// <summary>
		/// Optional, A free-form string containing a human-readable description of CIMStatusCode. This description MAY extend, but MUST be consistent with, the definition of CIMStatusCode.
		/// </summary>
		[CimField(false, false)]
		public virtual string CIMStatusCodeDescription
		{
			get
			{
				return this.GetField("CIMStatusCodeDescription")[0];
			}
			set
			{
			this.SetOrAddField("CIMStatusCodeDescription",value);
			}
		}
		/// <summary>
		/// Remove ErrorSource field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorSource()
		{
			RemoveField("ErrorSource");
		}

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

		/// <summary>
		/// Optional, The identifying information of the entity (i.e., the instance) generating the error. If this entity is modeled in the CIM Schema, this property contains the path of the instance encoded as a string parameter. If not modeled, the property contains some identifying string that names the entity that generated the error. The path or identifying string is formatted per the ErrorSourceFormat property.
		/// </summary>
		[CimField(false, false)]
		public virtual string ErrorSource
		{
			get
			{
				return this.GetField("ErrorSource")[0];
			}
			set
			{
			this.SetOrAddField("ErrorSource",value);
			}
		}
		/// <summary>
		/// Remove ErrorSourceFormat field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorSourceFormat()
		{
			RemoveField("ErrorSourceFormat");
		}

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

		/// <summary>
		/// Optional, The format of the ErrorSource property is interpretable based on 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 OtherErrorSourceFormat property.2 - CIMObjectPath. A CIM Object Path as defined in the CIM Infrastructure specification. Note: CIM 2.5 and earlier used the term object names.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ErrorSourceFormat
		{
			get
			{
					return ushort.Parse(this["ErrorSourceFormat"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorSourceFormat",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorType()
		{
			RemoveField("ErrorType");
		}

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

		/// <summary>
		/// Optional, Primary classification of the error. The following values are defined: 
		/// 2 - Communications Error. Errors of this type are principally associated with the procedures and/or processes required to convey information from one point to another. 
		/// 3 - Quality of Service Error. Errors of this type are principally associated with failures that result in reduced functionality or performance. 
		/// 4 - Software Error. Error of this type are principally associated with a software or processing fault. 
		/// 5 - Hardware Error. Errors of this type are principally associated with an equipment or hardware failure. 
		/// 6 - Environmental Error. Errors of this type are principally associated with a failure condition relating the to facility, or other environmental considerations. 
		/// 7 - Security Error. Errors of this type are associated with security violations, detection of viruses, and similar issues. 
		/// 8 - Oversubscription Error. Errors of this type are principally associated with the failure to allocate sufficient resources to complete the operation. 
		/// 9 - Unavailable Resource Error. Errors of this type are principally associated with the failure to access a required resource. 
		/// 10 -Unsupported Operation Error. Errors of this type are principally associated with requests that are not supported.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ErrorType
		{
			get
			{
					return ushort.Parse(this["ErrorType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorType",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <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>
		/// Required, An opaque string that uniquely identifies, within the scope of the OwningEntity, the format of the Message.
		/// </summary>
		[CimField(false, true)]
		public virtual string MessageID
		{
			get
			{
				return this.GetField("MessageID")[0];
			}
			set
			{
			this.SetOrAddField("MessageID",value);
			}
		}
		/// <summary>
		/// Remove OtherErrorSourceFormat field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherErrorSourceFormat()
		{
			RemoveField("OtherErrorSourceFormat");
		}

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

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

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

		/// <summary>
		/// Optional, A free-form string describing the ErrorType when 1, "Other", is specified as the ErrorType.
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherErrorType
		{
			get
			{
				return this.GetField("OtherErrorType")[0];
			}
			set
			{
			this.SetOrAddField("OtherErrorType",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>
		/// 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: 
		/// 0 - the Perceived Severity of the indication is unknown or indeterminate. 
		/// 1 - Other, by CIM convention, is used to indicate that the Severity's value can be found in the OtherSeverity property. 
		/// 2 - Information should be used when providing an informative response. 
		/// 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 Error 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 ProbableCause field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveProbableCause()
		{
			RemoveField("ProbableCause");
		}

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

		/// <summary>
		/// Optional, An enumerated value that describes the probable cause of the error.
		/// </summary>
		[CimField(false, false)]
		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, A free-form string describing the probable cause of the error.
		/// </summary>
		[CimField(false, false)]
		public virtual string ProbableCauseDescription
		{
			get
			{
				return this.GetField("ProbableCauseDescription")[0];
			}
			set
			{
			this.SetOrAddField("ProbableCauseDescription",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, A free-form string describing recommended actions to take to resolve the error.
		/// </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>
		/// Enumerate instances of CIM_Error 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_Error objects</returns>
		public static Collection<CIM_Error> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
		{
			List<CIM_Error> ret = CimBase.Enumerate<CIM_Error>(client, cimKeys);
			return new Collection<CIM_Error>(ret);
		}

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


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


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

		public new class CimKeys : CimBase.CimKeys
		{
		}

	}
}