//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_PETCapabilities.cs
//
//  Contents:   describes the attributes associated with a single logical sensor which can cause to event alerting. The logical model classifies sensors according to type regardless of the physical devices that implement them. Thus, a single physical sensor device can implement logical sensors of different types, such as temperature and voltage sensors.
//              This file was automatically generated from AMT_PETCapabilities.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>
	///describes the attributes associated with a single logical sensor which can cause to event alerting. The logical model classifies sensors according to type regardless of the physical devices that implement them. Thus, a single physical sensor device can implement logical sensors of different types, such as temperature and voltage sensors.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_PETCapabilities")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_PETCapabilities", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_PETCapabilities", IsNullable=false)]
	public class AMT_PETCapabilities : CIM_Capabilities
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_PETCapabilities() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_PETCapabilities(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_PETCapabilities(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AssertionEvent field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAssertionEvent()
		{
			RemoveField("AssertionEvent");
		}

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

		/// <summary>
		/// Optional, True if the assertion event is sent internally to the event handler. The event handler manages policies regarding whether the resulting event is sent in a PET frame and/or logged in the NV event log.
		/// </summary>
		[CimField(false, false)]
		public virtual bool AssertionEvent
		{
			get
			{
				return bool.Parse(this["AssertionEvent"][0]);
			}
			set
			{
				this.SetOrAddField("AssertionEvent",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove DeassertionEvent field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDeassertionEvent()
		{
			RemoveField("DeassertionEvent");
		}

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

		/// <summary>
		/// Optional, True if the de-assertion event is sent internally to the event handler. The event handler manages policies regarding whether the resulting event is sent in a PET frame and/or logged in the NV event log
		/// </summary>
		[CimField(false, false)]
		public virtual bool DeassertionEvent
		{
			get
			{
				return bool.Parse(this["DeassertionEvent"][0]);
			}
			set
			{
				this.SetOrAddField("DeassertionEvent",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <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 specification 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 specification 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 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 of the alert's Event Offset field (see PET specification 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 of the alert's Event Sensor Type field (see PET specification 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, The value of the alert's Event Severity field. 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 of the alert's Event Source Type field (see PET specification 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 of the alert's Event Type field (see PET specification 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 Index field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIndex()
		{
			RemoveField("Index");
		}

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

		/// <summary>
		/// Optional, If this is a legacy sensor, then this field contains the 0-based index of the ASF_ALERTDATA structure in the Device Array of the ASF_ALRT structure in the ACPI 'ASF!' structure. If this is an ASF sensor, then this field contains the value of the Event Status Index required for a Get Event Status cycle on the SMBus. The value in this field is used in determining how to poll the status of the device on the SMBus. Supported for backwards compatibility.
		/// </summary>
		[CimField(false, false)]
		public virtual byte Index
		{
			get
			{
					return byte.Parse(this["Index"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Index",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove IsLegacySensor field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIsLegacySensor()
		{
			RemoveField("IsLegacySensor");
		}

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

		/// <summary>
		/// Optional, The value in this field is TRUE if this is a legacy sensor described in the ACPI 'ASF!' table or FALSE if this is an ASF sensor. The value in this field is used in determining how to poll the status of the device on the SMBus.Supported for backwards compatibility.
		/// </summary>
		[CimField(false, false)]
		public virtual bool IsLegacySensor
		{
			get
			{
				return bool.Parse(this["IsLegacySensor"][0]);
			}
			set
			{
				this.SetOrAddField("IsLegacySensor",value.ToString().ToLower(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 of the alert's Sensor Number field (see PET specification 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_PETCapabilities 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_PETCapabilities objects</returns>
		public static new Collection<AMT_PETCapabilities> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
		{
			List<AMT_PETCapabilities> ret = CimBase.Enumerate<AMT_PETCapabilities>(client, cimKeys);
			return new Collection<AMT_PETCapabilities>(ret);
		}

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


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


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

		public new class CimKeys : CIM_Capabilities.CimKeys
		{
		}

	}
}