//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_LogicalDevice.cs
//
//  Contents:   An abstraction or emulation of a hardware entity, that may or may not be Realized in physical hardware. Any characteristics of a LogicalDevice that are used to manage its operation or configuration are contained in, or associated with, the LogicalDevice object. Examples of the operational properties of a Printer would be paper sizes supported, or detected errors. Examples of the configuration properties of a Sensor Device would be threshold settings. Various configurations could exist for a LogicalDevice. These configurations could be contained in Setting objects and associated with the LogicalDevice.
//              This file was automatically generated from CIM_LogicalDevice.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>
	///An abstraction or emulation of a hardware entity, that may or may not be Realized in physical hardware. Any characteristics of a LogicalDevice that are used to manage its operation or configuration are contained in, or associated with, the LogicalDevice object. Examples of the operational properties of a Printer would be paper sizes supported, or detected errors. Examples of the configuration properties of a Sensor Device would be threshold settings. Various configurations could exist for a LogicalDevice. These configurations could be contained in Setting objects and associated with the LogicalDevice.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_LogicalDevice", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
	public class CIM_LogicalDevice : CIM_EnabledLogicalElement
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_LogicalDevice() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_LogicalDevice(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_LogicalDevice(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AdditionalAvailability field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAdditionalAvailability()
		{
			RemoveField("AdditionalAvailability");
		}

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

		/// <summary>
		/// Optional, Additional availability and status of the Device, beyond that specified in the Availability property. The Availability property denotes the primary status and availability of the Device. In some cases, this will not be sufficient to denote the complete status of the Device. In those cases, the AdditionalAvailability property can be used to provide further information. For example, a Device's primary Availability may be "Off line" (value=8), but it may also be in a low power state (AdditonalAvailability value=14), or the Device could be running Diagnostics (AdditionalAvailability value=5, "In Test").
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] AdditionalAvailability
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["AdditionalAvailability"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("AdditionalAvailability", arr);
			}
		}
		/// <summary>
		/// Remove Availability field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAvailability()
		{
			RemoveField("Availability");
		}

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

		/// <summary>
		/// Optional, The primary availability and status of the Device. (Additional status information can be specified using the Additional Availability array property.) For example, the Availability property indicates that the Device is running and has full power (value=3), or is in a warning (4), test (5), degraded (10) or power save state (values 13-15 and 17). Regarding the Power Save states, these are defined as follows: Value 13 ("Power Save - Unknown") indicates that the Device is known to be in a power save mode, but its exact status in this mode is unknown; 14 ("Power Save - Low Power Mode") indicates that the Device is in a power save state but still functioning, and may exhibit degraded performance; 15 ("Power Save - Standby") describes that the Device is not functioning but could be brought to full power 'quickly'; and value 17 ("Power Save - Warning") indicates that the Device is in a warning state, though also in a power save mode.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort Availability
		{
			get
			{
					return ushort.Parse(this["Availability"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("Availability",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Key, Required, CreationClassName indicates the name of the class or the subclass used in the creation of an instance. When used with the other key properties of this class, this property allows all instances of this class and its subclasses to be uniquely identified.
		/// </summary>
		[CimField(true, true)]
		public virtual string CreationClassName
		{
			get
			{
				return this.GetField("CreationClassName")[0];
			}
			set
			{
			this.SetOrAddField("CreationClassName",value);
			}
		}


		/// <summary>
		/// Key, Required, An address or other identifying information to uniquely name the LogicalDevice.
		/// </summary>
		[CimField(true, true)]
		public virtual string DeviceID
		{
			get
			{
				return this.GetField("DeviceID")[0];
			}
			set
			{
			this.SetOrAddField("DeviceID",value);
			}
		}
		/// <summary>
		/// Remove ErrorCleared field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorCleared()
		{
			RemoveField("ErrorCleared");
		}

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

		/// <summary>
		/// Optional, ErrorCleared is a boolean property indicating that the error reported in LastErrorCode is now cleared.
		/// </summary>
		[CimField(false, false)]
		public virtual bool ErrorCleared
		{
			get
			{
				return bool.Parse(this["ErrorCleared"][0]);
			}
			set
			{
				this.SetOrAddField("ErrorCleared",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorDescription field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorDescription()
		{
			RemoveField("ErrorDescription");
		}

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

		/// <summary>
		/// Optional, ErrorDescription is a free-form string supplying more information about the error recorded in LastErrorCode, and information on any corrective actions that may be taken.
		/// </summary>
		[CimField(false, false)]
		public virtual string ErrorDescription
		{
			get
			{
				return this.GetField("ErrorDescription")[0];
			}
			set
			{
			this.SetOrAddField("ErrorDescription",value);
			}
		}
		/// <summary>
		/// Remove IdentifyingDescriptions field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIdentifyingDescriptions()
		{
			RemoveField("IdentifyingDescriptions");
		}

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

		/// <summary>
		/// Optional, An array of free-form strings providing explanations and details behind the entries in the OtherIdentifyingInfo array. Note, each entry of this array is related to the entry in OtherIdentifyingInfo that is located at the same index.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] IdentifyingDescriptions
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["IdentifyingDescriptions"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("IdentifyingDescriptions", arr);
			}
		}
		/// <summary>
		/// Remove LastErrorCode field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveLastErrorCode()
		{
			RemoveField("LastErrorCode");
		}

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

		/// <summary>
		/// Optional, LastErrorCode captures the last error code reported by the LogicalDevice.
		/// </summary>
		[CimField(false, false)]
		public virtual uint LastErrorCode
		{
			get
			{
					return uint.Parse(this["LastErrorCode"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("LastErrorCode",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove MaxQuiesceTime field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMaxQuiesceTime()
		{
			RemoveField("MaxQuiesceTime");
		}

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

		/// <summary>
		/// Optional, The MaxQuiesceTime property has been deprecated. When evaluating the use of Quiesce, it was determine that this single property is not adequate for describing when a device will automatically exit a quiescent state. In fact, the most likely scenario for a device to exit a quiescent state was determined to be based on the number of outstanding requests queued rather than on a maximum time. This will be re-evaluated and repositioned later. 
		/// Maximum time in milliseconds, that a Device can run in a "Quiesced" state. A Device's state is defined in its Availability and AdditionalAvailability properties, where "Quiesced" is conveyed by the value 21. What occurs at the end of the time limit is device-specific. The Device may unquiesce, may offline or take other action. A value of 0 indicates that a Device can remain quiesced indefinitely.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong MaxQuiesceTime
		{
			get
			{
					return ulong.Parse(this["MaxQuiesceTime"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("MaxQuiesceTime",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OtherIdentifyingInfo field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherIdentifyingInfo()
		{
			RemoveField("OtherIdentifyingInfo");
		}

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

		/// <summary>
		/// Optional, OtherIdentifyingInfo captures additional data, beyond DeviceID information, that could be used to identify a LogicalDevice. One example would be to hold the Operating System's user friendly name for the Device in this property.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] OtherIdentifyingInfo
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["OtherIdentifyingInfo"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("OtherIdentifyingInfo", arr);
			}
		}
		/// <summary>
		/// Remove PowerManagementCapabilities field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePowerManagementCapabilities()
		{
			RemoveField("PowerManagementCapabilities");
		}

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

		/// <summary>
		/// Optional, An enumerated array describing the power management capabilities of the Device. The use of this property has been deprecated. Instead, the PowerCapabilites property in an associated PowerManagementCapabilities class should be used.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] PowerManagementCapabilities
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["PowerManagementCapabilities"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("PowerManagementCapabilities", arr);
			}
		}
		/// <summary>
		/// Remove PowerManagementSupported field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePowerManagementSupported()
		{
			RemoveField("PowerManagementSupported");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that the Device can be power managed. The use of this property has been deprecated. Instead, the existence of an associated PowerManagementCapabilities class (associated using the ElementCapabilities relationhip) indicates that power management is supported.
		/// </summary>
		[CimField(false, false)]
		public virtual bool PowerManagementSupported
		{
			get
			{
				return bool.Parse(this["PowerManagementSupported"][0]);
			}
			set
			{
				this.SetOrAddField("PowerManagementSupported",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove PowerOnHours field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePowerOnHours()
		{
			RemoveField("PowerOnHours");
		}

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

		/// <summary>
		/// Optional, The number of consecutive hours that this Device has been powered, since its last power cycle.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong PowerOnHours
		{
			get
			{
					return ulong.Parse(this["PowerOnHours"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PowerOnHours",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove StatusInfo field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveStatusInfo()
		{
			RemoveField("StatusInfo");
		}

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

		/// <summary>
		/// Optional, The StatusInfo property indicates whether the Logical Device is in an enabled (value = 3), disabled (value = 4) or some other (1) or unknown (2) state. If this property does not apply to the LogicalDevice, the value, 5 ("Not Applicable"), should be used. StatusInfo has been deprecated in lieu of a more clearly named property with additional enumerated values (EnabledState), that is inherited from ManagedSystemElement. 
		/// If a Device is ("Enabled")(value=3), it has been powered up, and is configured and operational. The Device may or may not be functionally active, depending on whether its Availability (or AdditionalAvailability) indicate that it is ("Running/Full Power")(value=3) or ("Off line") (value=8). In an enabled but offline mode, a Device may be performing out-of-band requests, such as running Diagnostics. If ("Disabled") StatusInfo value=4), a Device can only be "enabled" or powered off. In a personal computer environment, ("Disabled") means that the Device's driver is not available in the stack. In other environments, a Device can be disabled by removing its configuration file. A disabled device is physically present in a System and consuming resources, but can not be communicated with until a load of a driver, a load of a configuration file or some other "enabling" activity has occurred.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort StatusInfo
		{
			get
			{
					return ushort.Parse(this["StatusInfo"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("StatusInfo",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Key, Required, The scoping System's CreationClassName.
		/// </summary>
		[CimField(true, true)]
		public virtual string SystemCreationClassName
		{
			get
			{
				return this.GetField("SystemCreationClassName")[0];
			}
			set
			{
			this.SetOrAddField("SystemCreationClassName",value);
			}
		}


		/// <summary>
		/// Key, Required, The scoping System's Name.
		/// </summary>
		[CimField(true, true)]
		public virtual string SystemName
		{
			get
			{
				return this.GetField("SystemName")[0];
			}
			set
			{
			this.SetOrAddField("SystemName",value);
			}
		}
		/// <summary>
		/// Remove TotalPowerOnHours field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTotalPowerOnHours()
		{
			RemoveField("TotalPowerOnHours");
		}

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

		/// <summary>
		/// Optional, The total number of hours that this Device has been powered.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong TotalPowerOnHours
		{
			get
			{
					return ulong.Parse(this["TotalPowerOnHours"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("TotalPowerOnHours",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		///Sets the power state of the Device. The use of this method has been deprecated. Instead, use the SetPowerState method in the associated PowerManagementService class.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class SetPowerState_INPUT : CimParams
		{
			public SetPowerState_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, The power state to set.
			/// </summary>
			[CimField(false,false)]
			public virtual ushort PowerState
			{
				set
				{
					this.SetOrAddField("PowerState",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Optional, Time indicates when the power state should be set, either as a regular date-time value or as an interval value (where the interval begins when the method invocation is received.
			/// </summary>
			[CimField(false,false)]
			public virtual CimDateTime Time
			{
				set
				{
					this.SetOrAddField("Time",value.ToString());
				}
			}
		}
		/// <summary>
		///Sets the power state of the Device. The use of this method has been deprecated. Instead, use the SetPowerState method in the associated PowerManagementService class.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class SetPowerState_OUTPUT : CimParams
		{
			public SetPowerState_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Sets the power state of the Device. The use of this method has been deprecated. Instead, use the SetPowerState method in the associated PowerManagementService class.
		/// </summary>
		/// <param name="inPowerState">Optional, IN -The power state to set.</param>
		/// <param name="inTime">Optional, IN -Time indicates when the power state should be set, either as a regular date-time value or as an interval value (where the interval begins when the method invocation is received.</param>
		/// <returns>
		/// </returns>
		public virtual uint SetPowerState(ushort? inPowerState,CimDateTime inTime)
		{
			SetPowerState_INPUT input = new SetPowerState_INPUT(this.XmlNamespace);
			if (inPowerState.HasValue)
				input.PowerState=inPowerState.Value;
			if (inTime != null)
				input.Time=inTime;
			SetPowerState_OUTPUT output = new SetPowerState_OUTPUT();
			uint returnValue = base.Invoke("SetPowerState",input,out output);
			return returnValue;
		}
		/// <summary>
		///Requests a reset of the LogicalDevice. The return value should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class Reset_INPUT : CimParams
		{
			public Reset_INPUT(string ns) : base(ns)
			{
			}

		}
		/// <summary>
		///Requests a reset of the LogicalDevice. The return value should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class Reset_OUTPUT : CimParams
		{
			public Reset_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Requests a reset of the LogicalDevice. The return value should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		/// <returns>
		/// </returns>
		public virtual uint Reset()
		{
			Reset_INPUT input = new Reset_INPUT(this.XmlNamespace);
			Reset_OUTPUT output = new Reset_OUTPUT();
			uint returnValue = base.Invoke("Reset",input,out output);
			return returnValue;
		}
		/// <summary>
		///The EnableDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice be enabled ("Enabled" input parameter = TRUE) or disabled (= FALSE). If successful, the Device's StatusInfo/EnabledState properties should reflect the desired state (enabled/disabled). Note that this method's function overlaps with the RequestedState property. RequestedState was added to the model to maintain a record (i.e., a persisted value) of the last state request. Invoking the EnableDevice method should set the RequestedState property appropriately. 
		///The return code should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class EnableDevice_INPUT : CimParams
		{
			public EnableDevice_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, If TRUE enable the device, if FALSE disable the device.
			/// </summary>
			[CimField(false,false)]
			public virtual bool Enabled
			{
				set
				{
					this.SetOrAddField("Enabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///The EnableDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice be enabled ("Enabled" input parameter = TRUE) or disabled (= FALSE). If successful, the Device's StatusInfo/EnabledState properties should reflect the desired state (enabled/disabled). Note that this method's function overlaps with the RequestedState property. RequestedState was added to the model to maintain a record (i.e., a persisted value) of the last state request. Invoking the EnableDevice method should set the RequestedState property appropriately. 
		///The return code should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class EnableDevice_OUTPUT : CimParams
		{
			public EnableDevice_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///The EnableDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice be enabled ("Enabled" input parameter = TRUE) or disabled (= FALSE). If successful, the Device's StatusInfo/EnabledState properties should reflect the desired state (enabled/disabled). Note that this method's function overlaps with the RequestedState property. RequestedState was added to the model to maintain a record (i.e., a persisted value) of the last state request. Invoking the EnableDevice method should set the RequestedState property appropriately. 
		///The return code should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		/// <param name="inEnabled">Optional, IN -If TRUE enable the device, if FALSE disable the device.</param>
		/// <returns>
		/// </returns>
		public virtual uint EnableDevice(bool? inEnabled)
		{
			EnableDevice_INPUT input = new EnableDevice_INPUT(this.XmlNamespace);
			if (inEnabled.HasValue)
				input.Enabled=inEnabled.Value;
			EnableDevice_OUTPUT output = new EnableDevice_OUTPUT();
			uint returnValue = base.Invoke("EnableDevice",input,out output);
			return returnValue;
		}
		/// <summary>
		///The OnlineDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice be brought online ("Online" input parameter = TRUE) or taken offline (= FALSE). "Online" indicates that the Device is ready to accept requests, and is operational and fully functioning. In this case, the Device's Availability property would be set to a value of 3 ("Running/Full Power"). "Offline" indicates that a Device is powered up and operational, but not processing functional requests. In an offline state, a Device may be capable of running diagnostics or generating operational alerts. For example, when the "Offline" button is pushed on a Printer, the Device is no longer available to process print jobs, but could be available for diagnostics or maintenance. 
		///If this method is successful, the Device's Availability and AdditionalAvailability properties should reflect the updated status. If a failure occurs trying to bring the Device online or offline, it should remain in its current state. IE, the request, if unsuccessful, should not leave the Device in an indeterminate state. When bringing a Device back "Online", from an "Offline" mode, the Device should be restored to its last "Online" state, if at all possible. Only a Device that has an EnabledState/StatusInfo of "Enabled" and has been configured can be brought online or taken offline. 
		///OnlineDevice should return 0 if successful, 1 if the request is not supported at all, 2 if the request is not supported due to the current state of the Device, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier. 
		///Note that this method's function overlaps with the RequestedState property. RequestedState was added to the model to maintain a record (i.e., a persisted value) of the last state request. Invoking the OnlineDevice method should set the RequestedState property appropriately.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class OnlineDevice_INPUT : CimParams
		{
			public OnlineDevice_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, If TRUE, take the device online, if FALSE, take the device OFFLINE.
			/// </summary>
			[CimField(false,false)]
			public virtual bool Online
			{
				set
				{
					this.SetOrAddField("Online",value.ToString().ToLower(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///The OnlineDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice be brought online ("Online" input parameter = TRUE) or taken offline (= FALSE). "Online" indicates that the Device is ready to accept requests, and is operational and fully functioning. In this case, the Device's Availability property would be set to a value of 3 ("Running/Full Power"). "Offline" indicates that a Device is powered up and operational, but not processing functional requests. In an offline state, a Device may be capable of running diagnostics or generating operational alerts. For example, when the "Offline" button is pushed on a Printer, the Device is no longer available to process print jobs, but could be available for diagnostics or maintenance. 
		///If this method is successful, the Device's Availability and AdditionalAvailability properties should reflect the updated status. If a failure occurs trying to bring the Device online or offline, it should remain in its current state. IE, the request, if unsuccessful, should not leave the Device in an indeterminate state. When bringing a Device back "Online", from an "Offline" mode, the Device should be restored to its last "Online" state, if at all possible. Only a Device that has an EnabledState/StatusInfo of "Enabled" and has been configured can be brought online or taken offline. 
		///OnlineDevice should return 0 if successful, 1 if the request is not supported at all, 2 if the request is not supported due to the current state of the Device, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier. 
		///Note that this method's function overlaps with the RequestedState property. RequestedState was added to the model to maintain a record (i.e., a persisted value) of the last state request. Invoking the OnlineDevice method should set the RequestedState property appropriately.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class OnlineDevice_OUTPUT : CimParams
		{
			public OnlineDevice_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///The OnlineDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice be brought online ("Online" input parameter = TRUE) or taken offline (= FALSE). "Online" indicates that the Device is ready to accept requests, and is operational and fully functioning. In this case, the Device's Availability property would be set to a value of 3 ("Running/Full Power"). "Offline" indicates that a Device is powered up and operational, but not processing functional requests. In an offline state, a Device may be capable of running diagnostics or generating operational alerts. For example, when the "Offline" button is pushed on a Printer, the Device is no longer available to process print jobs, but could be available for diagnostics or maintenance. 
		///If this method is successful, the Device's Availability and AdditionalAvailability properties should reflect the updated status. If a failure occurs trying to bring the Device online or offline, it should remain in its current state. IE, the request, if unsuccessful, should not leave the Device in an indeterminate state. When bringing a Device back "Online", from an "Offline" mode, the Device should be restored to its last "Online" state, if at all possible. Only a Device that has an EnabledState/StatusInfo of "Enabled" and has been configured can be brought online or taken offline. 
		///OnlineDevice should return 0 if successful, 1 if the request is not supported at all, 2 if the request is not supported due to the current state of the Device, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier. 
		///Note that this method's function overlaps with the RequestedState property. RequestedState was added to the model to maintain a record (i.e., a persisted value) of the last state request. Invoking the OnlineDevice method should set the RequestedState property appropriately.
		/// </summary>
		/// <param name="inOnline">Optional, IN -If TRUE, take the device online, if FALSE, take the device OFFLINE.</param>
		/// <returns>
		/// </returns>
		public virtual uint OnlineDevice(bool? inOnline)
		{
			OnlineDevice_INPUT input = new OnlineDevice_INPUT(this.XmlNamespace);
			if (inOnline.HasValue)
				input.Online=inOnline.Value;
			OnlineDevice_OUTPUT output = new OnlineDevice_OUTPUT();
			uint returnValue = base.Invoke("OnlineDevice",input,out output);
			return returnValue;
		}
		/// <summary>
		///The QuiesceDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice cleanly cease all current activity ("Quiesce" input parameter = TRUE) or resume activity (= FALSE). For this method to quiesce a Device, that Device should have an Availability (or Additional Availability) of "Running/Full Power" (value=3) and an EnabledStatus/StatusInfo of "Enabled". For example, if quiesced, a Device may then be offlined for diagnostics, or disabled for power off and hot swap. For the method to "unquiesce" a Device, that Device should have an Availability (or AdditionalAvailability) of "Quiesced" (value=21) and an EnabledStatus/StatusInfo of "Enabled". In this case, the Device would be returned to an "Enabled" and "Running/Full Power" status. 
		///The method's return code should indicate the success or failure of the quiesce. It should return 0 if successful, 1 if the request is not supported at all, 2 if the request is not supported due to the current state of the Device, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class QuiesceDevice_INPUT : CimParams
		{
			public QuiesceDevice_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, If set to TRUE then cleanly cease all activity, if FALSE resume activity.
			/// </summary>
			[CimField(false,false)]
			public virtual bool Quiesce
			{
				set
				{
					this.SetOrAddField("Quiesce",value.ToString().ToLower(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///The QuiesceDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice cleanly cease all current activity ("Quiesce" input parameter = TRUE) or resume activity (= FALSE). For this method to quiesce a Device, that Device should have an Availability (or Additional Availability) of "Running/Full Power" (value=3) and an EnabledStatus/StatusInfo of "Enabled". For example, if quiesced, a Device may then be offlined for diagnostics, or disabled for power off and hot swap. For the method to "unquiesce" a Device, that Device should have an Availability (or AdditionalAvailability) of "Quiesced" (value=21) and an EnabledStatus/StatusInfo of "Enabled". In this case, the Device would be returned to an "Enabled" and "Running/Full Power" status. 
		///The method's return code should indicate the success or failure of the quiesce. It should return 0 if successful, 1 if the request is not supported at all, 2 if the request is not supported due to the current state of the Device, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class QuiesceDevice_OUTPUT : CimParams
		{
			public QuiesceDevice_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///The QuiesceDevice method has been deprecated in lieu of the more general RequestStateChange method that directly overlaps with the functionality provided by this method. 
		///Requests that the LogicalDevice cleanly cease all current activity ("Quiesce" input parameter = TRUE) or resume activity (= FALSE). For this method to quiesce a Device, that Device should have an Availability (or Additional Availability) of "Running/Full Power" (value=3) and an EnabledStatus/StatusInfo of "Enabled". For example, if quiesced, a Device may then be offlined for diagnostics, or disabled for power off and hot swap. For the method to "unquiesce" a Device, that Device should have an Availability (or AdditionalAvailability) of "Quiesced" (value=21) and an EnabledStatus/StatusInfo of "Enabled". In this case, the Device would be returned to an "Enabled" and "Running/Full Power" status. 
		///The method's return code should indicate the success or failure of the quiesce. It should return 0 if successful, 1 if the request is not supported at all, 2 if the request is not supported due to the current state of the Device, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		/// <param name="inQuiesce">Optional, IN -If set to TRUE then cleanly cease all activity, if FALSE resume activity.</param>
		/// <returns>
		/// </returns>
		public virtual uint QuiesceDevice(bool? inQuiesce)
		{
			QuiesceDevice_INPUT input = new QuiesceDevice_INPUT(this.XmlNamespace);
			if (inQuiesce.HasValue)
				input.Quiesce=inQuiesce.Value;
			QuiesceDevice_OUTPUT output = new QuiesceDevice_OUTPUT();
			uint returnValue = base.Invoke("QuiesceDevice",input,out output);
			return returnValue;
		}
		/// <summary>
		///Requests that the Device capture its current configuration, setup and/or state information in a backing store. The goal would be to use this information at a later time (via the RestoreProperties method), to return a Device to its present "condition". This method may not be supported by all Devices. The method should return 0 if successful, 1 if the request is not supported, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class SaveProperties_INPUT : CimParams
		{
			public SaveProperties_INPUT(string ns) : base(ns)
			{
			}

		}
		/// <summary>
		///Requests that the Device capture its current configuration, setup and/or state information in a backing store. The goal would be to use this information at a later time (via the RestoreProperties method), to return a Device to its present "condition". This method may not be supported by all Devices. The method should return 0 if successful, 1 if the request is not supported, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class SaveProperties_OUTPUT : CimParams
		{
			public SaveProperties_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Requests that the Device capture its current configuration, setup and/or state information in a backing store. The goal would be to use this information at a later time (via the RestoreProperties method), to return a Device to its present "condition". This method may not be supported by all Devices. The method should return 0 if successful, 1 if the request is not supported, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		/// <returns>
		/// </returns>
		public virtual uint SaveProperties()
		{
			SaveProperties_INPUT input = new SaveProperties_INPUT(this.XmlNamespace);
			SaveProperties_OUTPUT output = new SaveProperties_OUTPUT();
			uint returnValue = base.Invoke("SaveProperties",input,out output);
			return returnValue;
		}
		/// <summary>
		///Requests that the Device re-establish its configuration, setup and/or state information from a backing store. The intent is to capture this information at an earlier time (via the SaveProperties method), and use it to return a Device to this earlier "condition". This method may not be supported by all Devices. The method should return 0 if successful, 1 if the request is not supported, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class RestoreProperties_INPUT : CimParams
		{
			public RestoreProperties_INPUT(string ns) : base(ns)
			{
			}

		}
		/// <summary>
		///Requests that the Device re-establish its configuration, setup and/or state information from a backing store. The intent is to capture this information at an earlier time (via the SaveProperties method), and use it to return a Device to this earlier "condition". This method may not be supported by all Devices. The method should return 0 if successful, 1 if the request is not supported, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_LogicalDevice", IsNullable=false)]
		private class RestoreProperties_OUTPUT : CimParams
		{
			public RestoreProperties_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Requests that the Device re-establish its configuration, setup and/or state information from a backing store. The intent is to capture this information at an earlier time (via the SaveProperties method), and use it to return a Device to this earlier "condition". This method may not be supported by all Devices. The method should return 0 if successful, 1 if the request is not supported, and some other value if any other error occurred. In a subclass, the set of possible return codes could be specified, using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
		/// </summary>
		/// <returns>
		/// </returns>
		public virtual uint RestoreProperties()
		{
			RestoreProperties_INPUT input = new RestoreProperties_INPUT(this.XmlNamespace);
			RestoreProperties_OUTPUT output = new RestoreProperties_OUTPUT();
			uint returnValue = base.Invoke("RestoreProperties",input,out output);
			return returnValue;
		}

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

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


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


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

		public new class CimKeys : CIM_EnabledLogicalElement.CimKeys
		{
			/// <summary>
			/// Key, Required, CreationClassName indicates the name of the class or the subclass used in the creation of an instance. When used with the other key properties of this class, this property allows all instances of this class and its subclasses to be uniquely identified.
			/// </summary>

			public virtual string CreationClassName
			{
				get
				{
					return GetKey("CreationClassName");
				}
				set
				{
					SetOrAddKey("CreationClassName", value);
				}
			}
			/// <summary>
			/// Key, Required, An address or other identifying information to uniquely name the LogicalDevice.
			/// </summary>

			public virtual string DeviceID
			{
				get
				{
					return GetKey("DeviceID");
				}
				set
				{
					SetOrAddKey("DeviceID", value);
				}
			}
			/// <summary>
			/// Key, Required, The scoping System's CreationClassName.
			/// </summary>

			public virtual string SystemCreationClassName
			{
				get
				{
					return GetKey("SystemCreationClassName");
				}
				set
				{
					SetOrAddKey("SystemCreationClassName", value);
				}
			}
			/// <summary>
			/// Key, Required, The scoping System's Name.
			/// </summary>

			public virtual string SystemName
			{
				get
				{
					return GetKey("SystemName");
				}
				set
				{
					SetOrAddKey("SystemName", value);
				}
			}
		}

	}
}