//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_Card.cs
//
//  Contents:   The Card class represents a type of physical container that can be plugged into another Card or HostingBoard, or is itself a HostingBoard/Motherboard in a Chassis. The CIM_Card class includes any package capable of carrying signals and providing a mounting point for PhysicalComponents, such as Chips, or other PhysicalPackages, such as other Cards.
//              This file was automatically generated from CIM_Card.mof
//
//----------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Globalization;
using System.Xml.Serialization;
using System.IO;
using Intel.Manageability.WSManagement;
using Intel.Manageability.Cim.Untyped;


namespace Intel.Manageability.Cim.Typed
{
	/// <summary>
	///The Card class represents a type of physical container that can be plugged into another Card or HostingBoard, or is itself a HostingBoard/Motherboard in a Chassis. The CIM_Card class includes any package capable of carrying signals and providing a mounting point for PhysicalComponents, such as Chips, or other PhysicalPackages, such as other Cards.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Card")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_Card", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Card", IsNullable=false)]
	public class CIM_Card : CIM_PhysicalPackage
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_Card() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_Card(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_Card(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove HostingBoard field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveHostingBoard()
		{
			RemoveField("HostingBoard");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that this Card is a Motherboard or, more generically, a baseboard in a Chassis.
		/// </summary>
		[CimField(false, false)]
		public virtual bool HostingBoard
		{
			get
			{
				return bool.Parse(this["HostingBoard"][0]);
			}
			set
			{
				this.SetOrAddField("HostingBoard",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OperatingVoltages field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOperatingVoltages()
		{
			RemoveField("OperatingVoltages");
		}

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

		/// <summary>
		/// Optional, Operating voltages required by the Card.
		/// </summary>
		[CimField(false, false)]
		public virtual short[] OperatingVoltages
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<short>(this["OperatingVoltages"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<short>(value);
				this.SetOrAddField("OperatingVoltages", arr);
			}
		}
		/// <summary>
		/// Remove RequirementsDescription field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRequirementsDescription()
		{
			RemoveField("RequirementsDescription");
		}

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

		/// <summary>
		/// Optional, A free-form string describing the way(s) in which this Card is physically unique from other Cards. This property only has meaning when the corresponding boolean property, SpecialRequirements, is set to TRUE.
		/// </summary>
		[CimField(false, false)]
		public virtual string RequirementsDescription
		{
			get
			{
				return this.GetField("RequirementsDescription")[0];
			}
			set
			{
			this.SetOrAddField("RequirementsDescription",value);
			}
		}
		/// <summary>
		/// Remove RequiresDaughterBoard field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRequiresDaughterBoard()
		{
			RemoveField("RequiresDaughterBoard");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that at least one daughterboard or auxiliary Card is required in order to function properly.
		/// </summary>
		[CimField(false, false)]
		public virtual bool RequiresDaughterBoard
		{
			get
			{
				return bool.Parse(this["RequiresDaughterBoard"][0]);
			}
			set
			{
				this.SetOrAddField("RequiresDaughterBoard",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SlotLayout field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSlotLayout()
		{
			RemoveField("SlotLayout");
		}

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

		/// <summary>
		/// Optional, SlotLayout is a free-form string that describes the slot positioning, typical usage, restrictions, individual slot spacings or any other pertinent information for the slots on a Card.
		/// </summary>
		[CimField(false, false)]
		public virtual string SlotLayout
		{
			get
			{
				return this.GetField("SlotLayout")[0];
			}
			set
			{
			this.SetOrAddField("SlotLayout",value);
			}
		}
		/// <summary>
		/// Remove SpecialRequirements field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSpecialRequirements()
		{
			RemoveField("SpecialRequirements");
		}

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

		/// <summary>
		/// Optional, Boolean indicating that this Card is physically unique from other Cards of the same type and therefore requires a special Slot. For example, a double-wide Card requires two Slots. Another example is where a certain Card may be used for the same general function as other Cards but requires a special Slot (e.g., extra long), whereas the other Cards can be placed in any available Slot. If set to TRUE, then the corresponding property, RequirementsDescription, should specify the nature of the uniqueness or purpose of the Card.
		/// </summary>
		[CimField(false, false)]
		public virtual bool SpecialRequirements
		{
			get
			{
				return bool.Parse(this["SpecialRequirements"][0]);
			}
			set
			{
				this.SetOrAddField("SpecialRequirements",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_PhysicalPackage.CimKeys
		{
		}

	}
}