//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_EventLogEntry.cs
//
//  Contents:   The LogRecord object can describe the definitional format for entries in a MessageLog, or can be used to instantiate the actual records in the Log. The latter approach provides a great deal more semantic definition and management control over the individual entries in a MessageLog, than do the record manipulation methods of the Log class. It is recommended that the data in individual Log entries be modeled using subclasses of LogRecord, to avoid the creation of LogRecords with one property (such as RecordData) without semantics. Definitional formats for LogRecords could be specified by establishing a naming convention for the RecordID and Message Timestamp key properties.
//              This file was automatically generated from AMT_EventLogEntry.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 LogRecord object can describe the definitional format for entries in a MessageLog, or can be used to instantiate the actual records in the Log. The latter approach provides a great deal more semantic definition and management control over the individual entries in a MessageLog, than do the record manipulation methods of the Log class. It is recommended that the data in individual Log entries be modeled using subclasses of LogRecord, to avoid the creation of LogRecords with one property (such as RecordData) without semantics. Definitional formats for LogRecords could be specified by establishing a naming convention for the RecordID and Message Timestamp key properties.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EventLogEntry")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_EventLogEntry", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_EventLogEntry", IsNullable=false)]
	public class AMT_EventLogEntry : CIM_LogEntry
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_EventLogEntry() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_EventLogEntry(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_EventLogEntry(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove DeviceAddress field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDeviceAddress()
		{
			RemoveField("DeviceAddress");
		}

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

		/// <summary>
		/// Optional, The SMBus address of the physical sensor device that implements the logical sensor.
		/// </summary>
		[CimField(false, false)]
		public virtual byte DeviceAddress
		{
			get
			{
					return byte.Parse(this["DeviceAddress"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("DeviceAddress",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Entity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEntity()
		{
			RemoveField("Entity");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Entity field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte Entity
		{
			get
			{
					return byte.Parse(this["Entity"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Entity",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EntityInstance field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEntityInstance()
		{
			RemoveField("EntityInstance");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Entity Instance field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte EntityInstance
		{
			get
			{
					return byte.Parse(this["EntityInstance"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EntityInstance",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EventData field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventData()
		{
			RemoveField("EventData");
		}

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

		/// <summary>
		/// Optional, Describes optional event data sent in the PET packet. The values are defined in the ASF specification [ASF].
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] EventData
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<byte>(this["EventData"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<byte>(value);
				this.SetOrAddField("EventData", arr);
			}
		}
		/// <summary>
		/// Remove EventOffset field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventOffset()
		{
			RemoveField("EventOffset");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Event Offset field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte EventOffset
		{
			get
			{
					return byte.Parse(this["EventOffset"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EventOffset",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EventSensorType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventSensorType()
		{
			RemoveField("EventSensorType");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Event Sensor Type field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte EventSensorType
		{
			get
			{
					return byte.Parse(this["EventSensorType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EventSensorType",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EventSeverity field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventSeverity()
		{
			RemoveField("EventSeverity");
		}

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

		/// <summary>
		/// Optional, This field can be used to fill in the Event Severity field in a PET alert. The severity values are based on the 'DMI' severity values used for the generic sensor event/reading type code.
		/// </summary>
		[CimField(false, false)]
		public virtual byte EventSeverity
		{
			get
			{
					return byte.Parse(this["EventSeverity"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EventSeverity",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EventSourceType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventSourceType()
		{
			RemoveField("EventSourceType");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Event Source Type field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte EventSourceType
		{
			get
			{
					return byte.Parse(this["EventSourceType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EventSourceType",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EventType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEventType()
		{
			RemoveField("EventType");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Event Type field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte EventType
		{
			get
			{
					return byte.Parse(this["EventType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EventType",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SensorNumber field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSensorNumber()
		{
			RemoveField("SensorNumber");
		}

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

		/// <summary>
		/// Optional, The value to be set into the alert's Sensor Number field (see [PET] for definitions.)
		/// </summary>
		[CimField(false, false)]
		public virtual byte SensorNumber
		{
			get
			{
					return byte.Parse(this["SensorNumber"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("SensorNumber",value.ToString(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_LogEntry.CimKeys
		{
		}

	}
}