//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_PowerSupply.cs
//
//  Contents:   Capabilities and management of the PowerSupply LogicalDevice.
//              This file was automatically generated from CIM_PowerSupply.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>
	///Capabilities and management of the PowerSupply LogicalDevice.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PowerSupply")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_PowerSupply", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PowerSupply", IsNullable=false)]
	public class CIM_PowerSupply : CIM_LogicalDevice
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_PowerSupply() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_PowerSupply(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_PowerSupply(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove ActiveInputVoltage field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveActiveInputVoltage()
		{
			RemoveField("ActiveInputVoltage");
		}

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

		/// <summary>
		/// Optional, ActiveInputVoltage indicates which input voltage range is currently in use. Range 1, 2, or both can be specified using the values 3, 4, or 5, respectively. If the Supply is not currently drawing power, the value 6 ("Neither") can be specified. This information is necessary in the case of a UPS, a subclass of PowerSupply.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ActiveInputVoltage
		{
			get
			{
					return ushort.Parse(this["ActiveInputVoltage"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ActiveInputVoltage",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove IsSwitchingSupply field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIsSwitchingSupply()
		{
			RemoveField("IsSwitchingSupply");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that the PowerSupply is a switching (instead of linear) supply.
		/// </summary>
		[CimField(false, false)]
		public virtual bool IsSwitchingSupply
		{
			get
			{
				return bool.Parse(this["IsSwitchingSupply"][0]);
			}
			set
			{
				this.SetOrAddField("IsSwitchingSupply",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range1InputFrequencyHigh field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange1InputFrequencyHigh()
		{
			RemoveField("Range1InputFrequencyHigh");
		}

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

		/// <summary>
		/// Optional, The frequency (in hertz) at the high end of the Input Frequency Range 1 of this Power Supply. A value of 0 implies DC.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range1InputFrequencyHigh
		{
			get
			{
					return uint.Parse(this["Range1InputFrequencyHigh"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range1InputFrequencyHigh",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range1InputFrequencyLow field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange1InputFrequencyLow()
		{
			RemoveField("Range1InputFrequencyLow");
		}

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

		/// <summary>
		/// Optional, The frequency (in hertz) at the low end of the Input Frequency Range 1 of this Power Supply. A value of 0 implies DC.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range1InputFrequencyLow
		{
			get
			{
					return uint.Parse(this["Range1InputFrequencyLow"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range1InputFrequencyLow",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range1InputVoltageHigh field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange1InputVoltageHigh()
		{
			RemoveField("Range1InputVoltageHigh");
		}

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

		/// <summary>
		/// Optional, The high voltage of Input Voltage Range 1 for this Power Supply, in millivolts. A value of 0 denotes 'unknown'.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range1InputVoltageHigh
		{
			get
			{
					return uint.Parse(this["Range1InputVoltageHigh"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range1InputVoltageHigh",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range1InputVoltageLow field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange1InputVoltageLow()
		{
			RemoveField("Range1InputVoltageLow");
		}

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

		/// <summary>
		/// Optional, The low voltage of Input Voltage Range 1 for this Power Supply, in millivolts. A value of 0 denotes 'unknown'.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range1InputVoltageLow
		{
			get
			{
					return uint.Parse(this["Range1InputVoltageLow"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range1InputVoltageLow",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range2InputFrequencyHigh field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange2InputFrequencyHigh()
		{
			RemoveField("Range2InputFrequencyHigh");
		}

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

		/// <summary>
		/// Optional, The frequency (in hertz) at the high end of the Input Frequency Range 2 of this Power Supply. A value of 0 implies DC.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range2InputFrequencyHigh
		{
			get
			{
					return uint.Parse(this["Range2InputFrequencyHigh"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range2InputFrequencyHigh",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range2InputFrequencyLow field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange2InputFrequencyLow()
		{
			RemoveField("Range2InputFrequencyLow");
		}

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

		/// <summary>
		/// Optional, The frequency (in hertz) at the low end of the Input Frequency Range 2 of this Power Supply. A value of 0 implies DC.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range2InputFrequencyLow
		{
			get
			{
					return uint.Parse(this["Range2InputFrequencyLow"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range2InputFrequencyLow",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range2InputVoltageHigh field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange2InputVoltageHigh()
		{
			RemoveField("Range2InputVoltageHigh");
		}

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

		/// <summary>
		/// Optional, The high voltage of Input Voltage Range 2 for this Power Supply, in millivolts. A value of 0 denotes 'unknown'.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range2InputVoltageHigh
		{
			get
			{
					return uint.Parse(this["Range2InputVoltageHigh"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range2InputVoltageHigh",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Range2InputVoltageLow field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRange2InputVoltageLow()
		{
			RemoveField("Range2InputVoltageLow");
		}

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

		/// <summary>
		/// Optional, The low voltage of Input Voltage Range 2 for this Power Supply, in millivolts. A value of 0 denotes 'unknown'.
		/// </summary>
		[CimField(false, false)]
		public virtual uint Range2InputVoltageLow
		{
			get
			{
					return uint.Parse(this["Range2InputVoltageLow"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Range2InputVoltageLow",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove TotalOutputPower field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTotalOutputPower()
		{
			RemoveField("TotalOutputPower");
		}

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

		/// <summary>
		/// Optional, Represents the total output power of the PowerSupply in milliWatts. 0 denotes 'unknown'.
		/// </summary>
		[CimField(false, false)]
		public virtual uint TotalOutputPower
		{
			get
			{
					return uint.Parse(this["TotalOutputPower"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("TotalOutputPower",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove TypeOfRangeSwitching field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTypeOfRangeSwitching()
		{
			RemoveField("TypeOfRangeSwitching");
		}

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

		/// <summary>
		/// Optional, TypeOfRangeSwitching describes the kind of input voltage range switching that is implemented in this PowerSupply. For example, autoswitching can be specified (value=4).
		/// </summary>
		[CimField(false, false)]
		public virtual ushort TypeOfRangeSwitching
		{
			get
			{
					return ushort.Parse(this["TypeOfRangeSwitching"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("TypeOfRangeSwitching",value.ToString(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_LogicalDevice.CimKeys
		{
		}

	}
}