//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_SharedCredential.cs
//
//  Contents:   SharedCredential is a secret (such as a password or the response to a challenge question) that is shared between a principal and a particular SharedCredential security service. Secrets may be in the form of a password used for initial authentication, or as with a session key, used as part of a message to verify the originator of the message. It is important to note that SharedCredential is not just a password, but rather is the password used with a particular security service.
//              This file was automatically generated from CIM_SharedCredential.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>
	///SharedCredential is a secret (such as a password or the response to a challenge question) that is shared between a principal and a particular SharedCredential security service. Secrets may be in the form of a password used for initial authentication, or as with a session key, used as part of a message to verify the originator of the message. It is important to note that SharedCredential is not just a password, but rather is the password used with a particular security service.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_SharedCredential")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_SharedCredential", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_SharedCredential", IsNullable=false)]
	public class CIM_SharedCredential : CIM_Credential
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_SharedCredential() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_SharedCredential(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_SharedCredential(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove Algorithm field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAlgorithm()
		{
			RemoveField("Algorithm");
		}

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

		/// <summary>
		/// Optional, The transformation algorithm, if any, used to protect passwords before use in the protocol. For instance, Kerberos doesn't store passwords as the shared secret, but rather, a hash of the password.
		/// </summary>
		[CimField(false, false)]
		public virtual string Algorithm
		{
			get
			{
				return this.GetField("Algorithm")[0];
			}
			set
			{
			this.SetOrAddField("Algorithm",value);
			}
		}


		/// <summary>
		/// Key, Required, Within the scope of the instantiating Namespace, InstanceID opaquely and uniquely identifies an instance of this class. In order to ensure uniqueness within the NameSpace, the value of InstanceID SHOULD be constructed using the following 'preferred' algorithm: 
		/// &lt;OrgID&gt;:&lt;LocalID&gt; 
		/// Where &lt;OrgID&gt; and &lt;LocalID&gt; are separated by a colon ':', and where &lt;OrgID&gt; MUST include a copyrighted, trademarked or otherwise unique name that is owned by the business entity creating/defining the InstanceID, or is a registered ID that is assigned to the business entity by a recognized global authority. (This is similar to the &lt;Schema Name&gt;_&lt;Class Name&gt; structure of Schema class names.) In addition, to ensure uniqueness, &lt;OrgID&gt; MUST NOT contain a colon (':'). When using this algorithm, the first colon to appear in InstanceID MUST appear between &lt;OrgID&gt; and &lt;LocalID&gt;. 
		/// &lt;LocalID&gt; is chosen by the organizational entity and SHOULD not be re-used to identify different underlying (real-world) elements. If the above 'preferred' algorithm is not used, the defining entity MUST assure that the resultant InstanceID is not re-used across any InstanceIDs produced by this or other providers for this instance's NameSpace. 
		/// For DMTF defined instances, the 'preferred' algorithm MUST be used with the &lt;OrgID&gt; set to 'CIM'.
		/// </summary>
		[CimField(true, true)]
		public override string InstanceID
		{
			get
			{
				return this.GetField("InstanceID")[0];
			}
			set
			{
			this.SetOrAddField("InstanceID",value);
			}
		}
		/// <summary>
		/// Remove Protocol field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveProtocol()
		{
			RemoveField("Protocol");
		}

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

		/// <summary>
		/// Optional, The protocol with which the SharedCredential is used.
		/// </summary>
		[CimField(false, false)]
		public virtual string Protocol
		{
			get
			{
				return this.GetField("Protocol")[0];
			}
			set
			{
			this.SetOrAddField("Protocol",value);
			}
		}
		/// <summary>
		/// Remove RemoteID field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRemoteID()
		{
			RemoveField("RemoteID");
		}

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

		/// <summary>
		/// Optional, RemoteID is the name by which the principal is known at the remote secret key authentication service.
		/// </summary>
		[CimField(false, false)]
		public virtual string RemoteID
		{
			get
			{
				return this.GetField("RemoteID")[0];
			}
			set
			{
			this.SetOrAddField("RemoteID",value);
			}
		}
		/// <summary>
		/// Remove Secret field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSecret()
		{
			RemoveField("Secret");
		}

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

		/// <summary>
		/// Optional, The secret known by the principal.
		/// </summary>
		[CimField(false, false)]
		public virtual string Secret
		{
			get
			{
				return this.GetField("Secret")[0];
			}
			set
			{
			this.SetOrAddField("Secret",value);
			}
		}

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

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


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


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

		public new class CimKeys : CIM_Credential.CimKeys
		{
			/// <summary>
			/// Key, Required, Within the scope of the instantiating Namespace, InstanceID opaquely and uniquely identifies an instance of this class. In order to ensure uniqueness within the NameSpace, the value of InstanceID SHOULD be constructed using the following 'preferred' algorithm: 
			/// &lt;OrgID&gt;:&lt;LocalID&gt; 
			/// Where &lt;OrgID&gt; and &lt;LocalID&gt; are separated by a colon ':', and where &lt;OrgID&gt; MUST include a copyrighted, trademarked or otherwise unique name that is owned by the business entity creating/defining the InstanceID, or is a registered ID that is assigned to the business entity by a recognized global authority. (This is similar to the &lt;Schema Name&gt;_&lt;Class Name&gt; structure of Schema class names.) In addition, to ensure uniqueness, &lt;OrgID&gt; MUST NOT contain a colon (':'). When using this algorithm, the first colon to appear in InstanceID MUST appear between &lt;OrgID&gt; and &lt;LocalID&gt;. 
			/// &lt;LocalID&gt; is chosen by the organizational entity and SHOULD not be re-used to identify different underlying (real-world) elements. If the above 'preferred' algorithm is not used, the defining entity MUST assure that the resultant InstanceID is not re-used across any InstanceIDs produced by this or other providers for this instance's NameSpace. 
			/// For DMTF defined instances, the 'preferred' algorithm MUST be used with the &lt;OrgID&gt; set to 'CIM'.
			/// </summary>

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

	}
}