//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_PhysicalFrame.cs
//
//  Contents:   PhysicalFrame is a superclass of Rack, Chassis and other frame enclosures, as they are defined in extension classes. Properties like visible or audible alarm, and data related to security breaches are in this superclass.
//              This file was automatically generated from CIM_PhysicalFrame.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>
	///PhysicalFrame is a superclass of Rack, Chassis and other frame enclosures, as they are defined in extension classes. Properties like visible or audible alarm, and data related to security breaches are in this superclass.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PhysicalFrame")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_PhysicalFrame", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PhysicalFrame", IsNullable=false)]
	public class CIM_PhysicalFrame : CIM_PhysicalPackage
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_PhysicalFrame() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_PhysicalFrame(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_PhysicalFrame(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AudibleAlarm field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAudibleAlarm()
		{
			RemoveField("AudibleAlarm");
		}

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

		/// <summary>
		/// Optional, Boolean indicating whether the Frame is equipped with an audible alarm.
		/// </summary>
		[CimField(false, false)]
		public virtual bool AudibleAlarm
		{
			get
			{
				return bool.Parse(this["AudibleAlarm"][0]);
			}
			set
			{
				this.SetOrAddField("AudibleAlarm",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove BreachDescription field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveBreachDescription()
		{
			RemoveField("BreachDescription");
		}

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

		/// <summary>
		/// Optional, BreachDescription is a free-form string providing more information if the SecurityBreach property indicates that a breach or some other security-related event occurred.
		/// </summary>
		[CimField(false, false)]
		public virtual string BreachDescription
		{
			get
			{
				return this.GetField("BreachDescription")[0];
			}
			set
			{
			this.SetOrAddField("BreachDescription",value);
			}
		}
		/// <summary>
		/// Remove CableManagementStrategy field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveCableManagementStrategy()
		{
			RemoveField("CableManagementStrategy");
		}

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

		/// <summary>
		/// Optional, CableManagementStrategy is a free-form string that contains information on how the various cables are connected and bundled for the Frame. With many networking, storage-related and power cables, cable management can be a complex and challenging endeavor. This string property contains information to aid in assembly and service of the Frame.
		/// </summary>
		[CimField(false, false)]
		public virtual string CableManagementStrategy
		{
			get
			{
				return this.GetField("CableManagementStrategy")[0];
			}
			set
			{
			this.SetOrAddField("CableManagementStrategy",value);
			}
		}
		/// <summary>
		/// Remove IsLocked field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIsLocked()
		{
			RemoveField("IsLocked");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that the Frame is currently locked.
		/// </summary>
		[CimField(false, false)]
		public virtual bool IsLocked
		{
			get
			{
				return bool.Parse(this["IsLocked"][0]);
			}
			set
			{
				this.SetOrAddField("IsLocked",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove LockPresent field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveLockPresent()
		{
			RemoveField("LockPresent");
		}

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

		/// <summary>
		/// Optional, Boolean indicating whether the Frame is protected with a lock.
		/// </summary>
		[CimField(false, false)]
		public virtual bool LockPresent
		{
			get
			{
				return bool.Parse(this["LockPresent"][0]);
			}
			set
			{
				this.SetOrAddField("LockPresent",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SecurityBreach field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSecurityBreach()
		{
			RemoveField("SecurityBreach");
		}

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

		/// <summary>
		/// Optional, SecurityBreach is an enumerated, integer-valued property indicating whether a physical breach of the Frame was attempted but unsuccessful (value=4) or attempted and successful (5). Also, the values, "Unknown", "Other" or "No Breach", can be specified.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort SecurityBreach
		{
			get
			{
					return ushort.Parse(this["SecurityBreach"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("SecurityBreach",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ServiceDescriptions field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveServiceDescriptions()
		{
			RemoveField("ServiceDescriptions");
		}

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

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

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

		/// <summary>
		/// Optional, ServicePhilosophy is an enumerated, integer-valued array that indicates whether the Frame is serviced from the top (value=2), front (3), back (4) or side (5), whether it has sliding trays (6) or removable sides (7), and/or whether the Frame is moveable (8), for example, having rollers.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] ServicePhilosophy
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["ServicePhilosophy"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("ServicePhilosophy", arr);
			}
		}
		/// <summary>
		/// Remove VisibleAlarm field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveVisibleAlarm()
		{
			RemoveField("VisibleAlarm");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that the equipment includes a visible alarm.
		/// </summary>
		[CimField(false, false)]
		public virtual bool VisibleAlarm
		{
			get
			{
				return bool.Parse(this["VisibleAlarm"][0]);
			}
			set
			{
				this.SetOrAddField("VisibleAlarm",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_PhysicalPackage.CimKeys
		{
		}

	}
}