//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_AuthorizationService.cs
//
//  Contents:   Describes the Authorization Service, which is responsible for Access Control management in the Intel(R) AMT subsystem.
//              This file was automatically generated from AMT_AuthorizationService.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>
	///Describes the Authorization Service, which is responsible for Access Control management in the Intel(R) AMT subsystem.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_AuthorizationService", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
	public class AMT_AuthorizationService : CIM_Service
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_AuthorizationService() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_AuthorizationService(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 AMT_AuthorizationService(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AllowHttpQopAuthOnly field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAllowHttpQopAuthOnly()
		{
			RemoveField("AllowHttpQopAuthOnly");
		}

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

		/// <summary>
		/// Optional, Indicates whether http digest authentication allows using qop="auth"
		/// </summary>
		[CimField(false, false)]
		public virtual uint AllowHttpQopAuthOnly
		{
			get
			{
					return uint.Parse(this["AllowHttpQopAuthOnly"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AllowHttpQopAuthOnly",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		///Adds a user entry to the Intel(R) AMT device.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class AddUserAclEntryEx_INPUT : CimParams
		{
			public AddUserAclEntryEx_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, Username for access control. Contains 7-bit ASCII characters. String length is limited to 16 characters. Username cannot be an empty string.
			/// </summary>
			[CimField(false,false)]
			public virtual string DigestUsername
			{
				set
				{
				this.SetOrAddField("DigestUsername",value);
				}
			}
			/// <summary>
			/// Optional, An MD5 Hash of these parameters concatenated together (Username + ":" + DigestRealm + ":" + Password). The DigestRealm is a field in AMT_GeneralSettings
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] DigestPassword
			{
				set
				{
				this.SetOrAddField("DigestPassword",Convert.ToBase64String(value));
				}
			}
			/// <summary>
			/// Optional, Descriptor for user (SID) which is authenticated using the Kerberos Authentication. Byte array, specifying the Security Identifier (SID) according to the Kerberos specification. Current requirements imply that SID should be not smaller than 1 byte length and no longer than 28 bytes. SID length should also be a multiplicand of 4.
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] KerberosUserSid
			{
				set
				{
				this.SetOrAddField("KerberosUserSid",Convert.ToBase64String(value));
				}
			}
			/// <summary>
			/// Required, Indicates whether the User is allowed to access Intel(R) AMT from the Network or Local Interfaces. Note: this definition is restricted by the Default Interface Access Permissions of each Realm.
			/// </summary>
			[CimField(false,true)]
			public virtual uint AccessPermission
			{
				set
				{
					this.SetOrAddField("AccessPermission",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Optional, Array of interface names the ACL entry is allowed to access.
			/// </summary>
			[CimField(false,false)]
			public virtual uint[] Realms
			{
				set
				{
					List<string> newArr = new List<string>();
					foreach (uint val in value)
					{
						newArr.Add(val.ToString(CultureInfo.InvariantCulture));
					}
					this.SetOrAddField("Realms",newArr.ToArray());
				}
			}
		}
		/// <summary>
		///Adds a user entry to the Intel(R) AMT device.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class AddUserAclEntryEx_OUTPUT : CimParams
		{
			public AddUserAclEntryEx_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, Contains a creation handle.
			/// </summary>
			[CimField(false,false)]
			public virtual uint Handle
			{
				get
				{
						return uint.Parse(this["Handle"][0], CultureInfo.InvariantCulture);
				}
			}
		}
		/// <summary>
		///Adds a user entry to the Intel(R) AMT device.
		/// </summary>
		/// <param name="inDigestUsername">Optional, IN -Username for access control. Contains 7-bit ASCII characters. String length is limited to 16 characters. Username cannot be an empty string.</param>
		/// <param name="inDigestPassword">Optional, IN -An MD5 Hash of these parameters concatenated together (Username + ":" + DigestRealm + ":" + Password). The DigestRealm is a field in AMT_GeneralSettings</param>
		/// <param name="inKerberosUserSid">Optional, IN -Descriptor for user (SID) which is authenticated using the Kerberos Authentication. Byte array, specifying the Security Identifier (SID) according to the Kerberos specification. Current requirements imply that SID should be not smaller than 1 byte length and no longer than 28 bytes. SID length should also be a multiplicand of 4.</param>
		/// <param name="inAccessPermission">Required, IN -Indicates whether the User is allowed to access Intel(R) AMT from the Network or Local Interfaces. Note: this definition is restricted by the Default Interface Access Permissions of each Realm.</param>
		/// <param name="inRealms">Optional, IN -Array of interface names the ACL entry is allowed to access.</param>
		/// <param name="outHandle">OUT - Contains a creation handle.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_INVALID_NAME : 12
		/// PT_STATUS_NOT_PERMITTED : 16
		/// PT_STATUS_MAX_LIMIT_REACHED : 23
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// PT_STATUS_INVALID_PASSWORD : 2054
		/// PT_STATUS_INVALID_REALM : 2055
		/// PT_STATUS_MAX_KERB_DOMAIN_REACHED : 2065
		/// PT_STATUS_AUDIT_FAIL : 2075
		/// </returns>
		public virtual uint AddUserAclEntryEx(string inDigestUsername,byte[] inDigestPassword,byte[] inKerberosUserSid,uint? inAccessPermission,uint[] inRealms,out uint outHandle)
		{
			AddUserAclEntryEx_INPUT input = new AddUserAclEntryEx_INPUT(this.XmlNamespace);
			if (inDigestUsername != null)
				input.DigestUsername=inDigestUsername;
			if (inDigestPassword != null)
				input.DigestPassword=inDigestPassword;
			if (inKerberosUserSid != null)
				input.KerberosUserSid=inKerberosUserSid;
			if (inAccessPermission.HasValue)
				input.AccessPermission=inAccessPermission.Value;
			if (inRealms != null)
				input.Realms=inRealms;
			AddUserAclEntryEx_OUTPUT output = new AddUserAclEntryEx_OUTPUT();
			uint returnValue = base.Invoke("AddUserAclEntryEx",input,out output);
			outHandle=0;
			if (returnValue == 0)
			{
				if (output.ContainsField("Handle"))
					outHandle = output.Handle;
			}
			return returnValue;
		}
		/// <summary>
		///Enumerates entries in the User Access Control List (ACL).
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class EnumerateUserAclEntries_INPUT : CimParams
		{
			public EnumerateUserAclEntries_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Indicates the first ACL entry to retrieve. To enumerate the entire list, an application sends this message with StartIndex set to 1.
			/// </summary>
			[CimField(false,true)]
			public virtual uint StartIndex
			{
				set
				{
					this.SetOrAddField("StartIndex",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Enumerates entries in the User Access Control List (ACL).
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class EnumerateUserAclEntries_OUTPUT : CimParams
		{
			public EnumerateUserAclEntries_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, Contains the total number of entries in the User ACL.
			/// </summary>
			[CimField(false,false)]
			public virtual uint TotalCount
			{
				get
				{
						return uint.Parse(this["TotalCount"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Contains the number of entries in the returned list.
			/// </summary>
			[CimField(false,false)]
			public virtual uint HandlesCount
			{
				get
				{
						return uint.Parse(this["HandlesCount"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Contains a list of HandleCount entry handles.
			/// </summary>
			[CimField(false,false)]
			public virtual uint[] Handles
			{
				get
				{
					string[] arr = this["Handles"];
					List<uint> newArr = new List<uint>();
					foreach (string str in arr)
					{
						newArr.Add(uint.Parse(str, CultureInfo.InvariantCulture));
					}
					return newArr.ToArray();
				}
			}
		}
		/// <summary>
		///Enumerates entries in the User Access Control List (ACL).
		/// </summary>
		/// <param name="inStartIndex">Required, IN -Indicates the first ACL entry to retrieve. To enumerate the entire list, an application sends this message with StartIndex set to 1.</param>
		/// <param name="outTotalCount">OUT - Contains the total number of entries in the User ACL.</param>
		/// <param name="outHandlesCount">OUT - Contains the number of entries in the returned list.</param>
		/// <param name="outHandles">OUT - Contains a list of HandleCount entry handles.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_INVALID_INDEX : 35
		/// </returns>
		public virtual uint EnumerateUserAclEntries(uint? inStartIndex,out uint outTotalCount,out uint outHandlesCount,out uint[] outHandles)
		{
			EnumerateUserAclEntries_INPUT input = new EnumerateUserAclEntries_INPUT(this.XmlNamespace);
			if (inStartIndex.HasValue)
				input.StartIndex=inStartIndex.Value;
			EnumerateUserAclEntries_OUTPUT output = new EnumerateUserAclEntries_OUTPUT();
			uint returnValue = base.Invoke("EnumerateUserAclEntries",input,out output);
			outTotalCount=0;
			outHandlesCount=0;
			outHandles=null;
			if (returnValue == 0)
			{
				if (output.ContainsField("TotalCount"))
					outTotalCount = output.TotalCount;
				if (output.ContainsField("HandlesCount"))
					outHandlesCount = output.HandlesCount;
				if (output.ContainsField("Handles"))
					outHandles = output.Handles;
			}
			return returnValue;
		}
		/// <summary>
		///Reads a user entry from the Intel(R) AMT device. Note: confidential information, such as password (hash) is omitted or zeroed in the response.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetUserAclEntryEx_INPUT : CimParams
		{
			public GetUserAclEntryEx_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Specifies the ACL entry to fetch.
			/// </summary>
			[CimField(false,true)]
			public virtual uint Handle
			{
				set
				{
					this.SetOrAddField("Handle",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Reads a user entry from the Intel(R) AMT device. Note: confidential information, such as password (hash) is omitted or zeroed in the response.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetUserAclEntryEx_OUTPUT : CimParams
		{
			public GetUserAclEntryEx_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, Username for access control.
			/// </summary>
			[CimField(false,false)]
			public virtual string DigestUsername
			{
				get
				{
					return this.GetField("DigestUsername")[0];
				}
			}
			/// <summary>
			/// Optional, Confidential information, such as password (hash) is omitted from the response.
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] DigestPassword
			{
				get
				{
						return Convert.FromBase64String(this.GetField("DigestPassword")[0]);				}
			}
			/// <summary>
			/// Optional, Descriptor for user (SID) which is authenticated using the Kerberos Authentication. Byte array, specifying the Security Identifier (SID) according to the Kerberos specification.
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] KerberosUserSid
			{
				get
				{
						return Convert.FromBase64String(this.GetField("KerberosUserSid")[0]);				}
			}
			/// <summary>
			/// Optional, Indicates whether the User is allowed to access Intel(R) AMT from the Network or Local Interfaces. Note: this definition is restricted by the Default Interface Access Permissions of each Realm.
			/// </summary>
			[CimField(false,false)]
			public virtual uint AccessPermission
			{
				get
				{
						return uint.Parse(this["AccessPermission"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Array of interface names the ACL entry is allowed to access.
			/// </summary>
			[CimField(false,false)]
			public virtual uint[] Realms
			{
				get
				{
					string[] arr = this["Realms"];
					List<uint> newArr = new List<uint>();
					foreach (string str in arr)
					{
						newArr.Add(uint.Parse(str, CultureInfo.InvariantCulture));
					}
					return newArr.ToArray();
				}
			}
		}
		/// <summary>
		///Reads a user entry from the Intel(R) AMT device. Note: confidential information, such as password (hash) is omitted or zeroed in the response.
		/// </summary>
		/// <param name="inHandle">Required, IN -Specifies the ACL entry to fetch.</param>
		/// <param name="outDigestUsername">OUT - Username for access control.</param>
		/// <param name="outDigestPassword">OUT - Confidential information, such as password (hash) is omitted from the response.</param>
		/// <param name="outKerberosUserSid">OUT - Descriptor for user (SID) which is authenticated using the Kerberos Authentication. Byte array, specifying the Security Identifier (SID) according to the Kerberos specification.</param>
		/// <param name="outAccessPermission">OUT - Indicates whether the User is allowed to access Intel(R) AMT from the Network or Local Interfaces. Note: this definition is restricted by the Default Interface Access Permissions of each Realm.</param>
		/// <param name="outRealms">OUT - Array of interface names the ACL entry is allowed to access.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_INVALID_HANDLE : 2053
		/// </returns>
		public virtual uint GetUserAclEntryEx(uint? inHandle,out string outDigestUsername,out byte[] outDigestPassword,out byte[] outKerberosUserSid,out uint outAccessPermission,out uint[] outRealms)
		{
			GetUserAclEntryEx_INPUT input = new GetUserAclEntryEx_INPUT(this.XmlNamespace);
			if (inHandle.HasValue)
				input.Handle=inHandle.Value;
			GetUserAclEntryEx_OUTPUT output = new GetUserAclEntryEx_OUTPUT();
			uint returnValue = base.Invoke("GetUserAclEntryEx",input,out output);
			outDigestUsername=null;
			outDigestPassword=null;
			outKerberosUserSid=null;
			outAccessPermission=0;
			outRealms=null;
			if (returnValue == 0)
			{
				if (output.ContainsField("DigestUsername"))
					outDigestUsername = output.DigestUsername;
				if (output.ContainsField("DigestPassword"))
					outDigestPassword = output.DigestPassword;
				if (output.ContainsField("KerberosUserSid"))
					outKerberosUserSid = output.KerberosUserSid;
				if (output.ContainsField("AccessPermission"))
					outAccessPermission = output.AccessPermission;
				if (output.ContainsField("Realms"))
					outRealms = output.Realms;
			}
			return returnValue;
		}
		/// <summary>
		///Updates a user entry in the Intel(R) AMT device.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class UpdateUserAclEntryEx_INPUT : CimParams
		{
			public UpdateUserAclEntryEx_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Creation handle to a User ACL entry.
			/// </summary>
			[CimField(false,true)]
			public virtual uint Handle
			{
				set
				{
					this.SetOrAddField("Handle",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Optional, Username for access control. Contains 7-bit ASCII characters. String length is limited to 16 characters. Username cannot be an empty string.
			/// </summary>
			[CimField(false,false)]
			public virtual string DigestUsername
			{
				set
				{
				this.SetOrAddField("DigestUsername",value);
				}
			}
			/// <summary>
			/// Optional, An MD5 Hash of these parameters concatenated together (Username + ":" + DigestRealm + ":" + Password). The DigestRealm is a field in AMT_GeneralSettings
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] DigestPassword
			{
				set
				{
				this.SetOrAddField("DigestPassword",Convert.ToBase64String(value));
				}
			}
			/// <summary>
			/// Optional, Descriptor for user (SID) which is authenticated using the Kerberos Authentication. Byte array, specifying the Security Identifier (SID) according to the Kerberos specification. Current requirements imply that SID should be not smaller than 1 byte length and no longer than 28 bytes. SID length should also be a multiplicand of 4.
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] KerberosUserSid
			{
				set
				{
				this.SetOrAddField("KerberosUserSid",Convert.ToBase64String(value));
				}
			}
			/// <summary>
			/// Required, Indicates whether the User is allowed to access Intel(R) AMT from the Network or Local Interfaces. Note: this definition is restricted by the Default Interface Access Permissions of each Realm.
			/// </summary>
			[CimField(false,true)]
			public virtual uint AccessPermission
			{
				set
				{
					this.SetOrAddField("AccessPermission",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Optional, Array of interface names the ACL entry is allowed to access.
			/// </summary>
			[CimField(false,false)]
			public virtual uint[] Realms
			{
				set
				{
					List<string> newArr = new List<string>();
					foreach (uint val in value)
					{
						newArr.Add(val.ToString(CultureInfo.InvariantCulture));
					}
					this.SetOrAddField("Realms",newArr.ToArray());
				}
			}
		}
		/// <summary>
		///Updates a user entry in the Intel(R) AMT device.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class UpdateUserAclEntryEx_OUTPUT : CimParams
		{
			public UpdateUserAclEntryEx_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Updates a user entry in the Intel(R) AMT device.
		/// </summary>
		/// <param name="inHandle">Required, IN -Creation handle to a User ACL entry.</param>
		/// <param name="inDigestUsername">Optional, IN -Username for access control. Contains 7-bit ASCII characters. String length is limited to 16 characters. Username cannot be an empty string.</param>
		/// <param name="inDigestPassword">Optional, IN -An MD5 Hash of these parameters concatenated together (Username + ":" + DigestRealm + ":" + Password). The DigestRealm is a field in AMT_GeneralSettings</param>
		/// <param name="inKerberosUserSid">Optional, IN -Descriptor for user (SID) which is authenticated using the Kerberos Authentication. Byte array, specifying the Security Identifier (SID) according to the Kerberos specification. Current requirements imply that SID should be not smaller than 1 byte length and no longer than 28 bytes. SID length should also be a multiplicand of 4.</param>
		/// <param name="inAccessPermission">Required, IN -Indicates whether the User is allowed to access Intel(R) AMT from the Network or Local Interfaces. Note: this definition is restricted by the Default Interface Access Permissions of each Realm.</param>
		/// <param name="inRealms">Optional, IN -Array of interface names the ACL entry is allowed to access.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_INVALID_NAME : 12
		/// PT_STATUS_NOT_PERMITTED : 16
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// PT_STATUS_INVALID_HANDLE : 2053
		/// PT_STATUS_INVALID_PASSWORD : 2054
		/// PT_STATUS_INVALID_REALM : 2055
		/// PT_STATUS_MAX_KERB_DOMAIN_REACHED : 2065
		/// PT_STATUS_AUDIT_FAIL : 2075
		/// </returns>
		public virtual uint UpdateUserAclEntryEx(uint? inHandle,string inDigestUsername,byte[] inDigestPassword,byte[] inKerberosUserSid,uint? inAccessPermission,uint[] inRealms)
		{
			UpdateUserAclEntryEx_INPUT input = new UpdateUserAclEntryEx_INPUT(this.XmlNamespace);
			if (inHandle.HasValue)
				input.Handle=inHandle.Value;
			if (inDigestUsername != null)
				input.DigestUsername=inDigestUsername;
			if (inDigestPassword != null)
				input.DigestPassword=inDigestPassword;
			if (inKerberosUserSid != null)
				input.KerberosUserSid=inKerberosUserSid;
			if (inAccessPermission.HasValue)
				input.AccessPermission=inAccessPermission.Value;
			if (inRealms != null)
				input.Realms=inRealms;
			UpdateUserAclEntryEx_OUTPUT output = new UpdateUserAclEntryEx_OUTPUT();
			uint returnValue = base.Invoke("UpdateUserAclEntryEx",input,out output);
			return returnValue;
		}
		/// <summary>
		///Removes an entry from the User Access Control List (ACL), given a handle.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class RemoveUserAclEntry_INPUT : CimParams
		{
			public RemoveUserAclEntry_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Specifies the ACL entry to be removed.
			/// </summary>
			[CimField(false,true)]
			public virtual uint Handle
			{
				set
				{
					this.SetOrAddField("Handle",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Removes an entry from the User Access Control List (ACL), given a handle.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class RemoveUserAclEntry_OUTPUT : CimParams
		{
			public RemoveUserAclEntry_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Removes an entry from the User Access Control List (ACL), given a handle.
		/// </summary>
		/// <param name="inHandle">Required, IN -Specifies the ACL entry to be removed.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_NOT_PERMITTED : 16
		/// PT_STATUS_INVALID_HANDLE : 2053
		/// PT_STATUS_AUDIT_FAIL : 2075
		/// </returns>
		public virtual uint RemoveUserAclEntry(uint? inHandle)
		{
			RemoveUserAclEntry_INPUT input = new RemoveUserAclEntry_INPUT(this.XmlNamespace);
			if (inHandle.HasValue)
				input.Handle=inHandle.Value;
			RemoveUserAclEntry_OUTPUT output = new RemoveUserAclEntry_OUTPUT();
			uint returnValue = base.Invoke("RemoveUserAclEntry",input,out output);
			return returnValue;
		}
		/// <summary>
		///Updates an Admin entry in the Intel(R) AMT device.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class SetAdminAclEntryEx_INPUT : CimParams
		{
			public SetAdminAclEntryEx_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Username for access control. Contains 7-bit ASCII characters. String length is limited to 16 characters. Username cannot be an empty string.
			/// </summary>
			[CimField(false,true)]
			public virtual string Username
			{
				set
				{
				this.SetOrAddField("Username",value);
				}
			}
			/// <summary>
			/// Required, An MD5 Hash of these parameters concatenated together (Username + ":" + DigestRealm + ":" + Password). The DigestRealm is a field in AMT_GeneralSettings
			/// </summary>
			[CimField(false,true)]
			public virtual byte[] DigestPassword
			{
				set
				{
				this.SetOrAddField("DigestPassword",Convert.ToBase64String(value));
				}
			}
		}
		/// <summary>
		///Updates an Admin entry in the Intel(R) AMT device.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class SetAdminAclEntryEx_OUTPUT : CimParams
		{
			public SetAdminAclEntryEx_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Updates an Admin entry in the Intel(R) AMT device.
		/// </summary>
		/// <param name="inUsername">Required, IN -Username for access control. Contains 7-bit ASCII characters. String length is limited to 16 characters. Username cannot be an empty string.</param>
		/// <param name="inDigestPassword">Required, IN -An MD5 Hash of these parameters concatenated together (Username + ":" + DigestRealm + ":" + Password). The DigestRealm is a field in AMT_GeneralSettings</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_INVALID_NAME : 12
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// PT_STATUS_INVALID_PASSWORD : 2054
		/// PT_STATUS_AUDIT_FAIL : 2075
		/// </returns>
		public virtual uint SetAdminAclEntryEx(string inUsername,byte[] inDigestPassword)
		{
			SetAdminAclEntryEx_INPUT input = new SetAdminAclEntryEx_INPUT(this.XmlNamespace);
			if (inUsername != null)
				input.Username=inUsername;
			if (inDigestPassword != null)
				input.DigestPassword=inDigestPassword;
			SetAdminAclEntryEx_OUTPUT output = new SetAdminAclEntryEx_OUTPUT();
			uint returnValue = base.Invoke("SetAdminAclEntryEx",input,out output);
			return returnValue;
		}
		/// <summary>
		///Returns the username attribute of the Admin ACL.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAdminAclEntry_INPUT : CimParams
		{
			public GetAdminAclEntry_INPUT(string ns) : base(ns)
			{
			}

		}
		/// <summary>
		///Returns the username attribute of the Admin ACL.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAdminAclEntry_OUTPUT : CimParams
		{
			public GetAdminAclEntry_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, Contains the username of the Admin ACL.
			/// </summary>
			[CimField(false,false)]
			public virtual string Username
			{
				get
				{
					return this.GetField("Username")[0];
				}
			}
		}
		/// <summary>
		///Returns the username attribute of the Admin ACL.
		/// </summary>
		/// <param name="outUsername">OUT - Contains the username of the Admin ACL.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// </returns>
		public virtual uint GetAdminAclEntry(out string outUsername)
		{
			GetAdminAclEntry_INPUT input = new GetAdminAclEntry_INPUT(this.XmlNamespace);
			GetAdminAclEntry_OUTPUT output = new GetAdminAclEntry_OUTPUT();
			uint returnValue = base.Invoke("GetAdminAclEntry",input,out output);
			outUsername=null;
			if (returnValue == 0)
			{
				if (output.ContainsField("Username"))
					outUsername = output.Username;
			}
			return returnValue;
		}
		/// <summary>
		///Reads the Admin ACL Entry status from Intel(R) AMT. The return state changes as a function of the admin password.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAdminAclEntryStatus_INPUT : CimParams
		{
			public GetAdminAclEntryStatus_INPUT(string ns) : base(ns)
			{
			}

		}
		/// <summary>
		///Reads the Admin ACL Entry status from Intel(R) AMT. The return state changes as a function of the admin password.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAdminAclEntryStatus_OUTPUT : CimParams
		{
			public GetAdminAclEntryStatus_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, TRUE if the admin ACL entry (admin password) was never changed by the user. Otherwise, the parameter is FALSE.
			/// </summary>
			[CimField(false,false)]
			public virtual bool IsDefault
			{
				get
				{
					return bool.Parse(this["IsDefault"][0]);
				}
			}
		}
		/// <summary>
		///Reads the Admin ACL Entry status from Intel(R) AMT. The return state changes as a function of the admin password.
		/// </summary>
		/// <param name="outIsDefault">OUT - TRUE if the admin ACL entry (admin password) was never changed by the user. Otherwise, the parameter is FALSE.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// </returns>
		public virtual uint GetAdminAclEntryStatus(out bool outIsDefault)
		{
			GetAdminAclEntryStatus_INPUT input = new GetAdminAclEntryStatus_INPUT(this.XmlNamespace);
			GetAdminAclEntryStatus_OUTPUT output = new GetAdminAclEntryStatus_OUTPUT();
			uint returnValue = base.Invoke("GetAdminAclEntryStatus",input,out output);
			outIsDefault=false;
			if (returnValue == 0)
			{
				if (output.ContainsField("IsDefault"))
					outIsDefault = output.IsDefault;
			}
			return returnValue;
		}
		/// <summary>
		///Reads the remote Admin ACL Entry status from Intel(R) AMT. The return state changes as a function of the remote admin password.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAdminNetAclEntryStatus_INPUT : CimParams
		{
			public GetAdminNetAclEntryStatus_INPUT(string ns) : base(ns)
			{
			}

		}
		/// <summary>
		///Reads the remote Admin ACL Entry status from Intel(R) AMT. The return state changes as a function of the remote admin password.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAdminNetAclEntryStatus_OUTPUT : CimParams
		{
			public GetAdminNetAclEntryStatus_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, TRUE if the remote admin ACL entry (remote admin password) was never changed by the user. Otherwise, the parameter is FALSE.
			/// </summary>
			[CimField(false,false)]
			public virtual bool IsDefault
			{
				get
				{
					return bool.Parse(this["IsDefault"][0]);
				}
			}
		}
		/// <summary>
		///Reads the remote Admin ACL Entry status from Intel(R) AMT. The return state changes as a function of the remote admin password.
		/// </summary>
		/// <param name="outIsDefault">OUT - TRUE if the remote admin ACL entry (remote admin password) was never changed by the user. Otherwise, the parameter is FALSE.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// </returns>
		public virtual uint GetAdminNetAclEntryStatus(out bool outIsDefault)
		{
			GetAdminNetAclEntryStatus_INPUT input = new GetAdminNetAclEntryStatus_INPUT(this.XmlNamespace);
			GetAdminNetAclEntryStatus_OUTPUT output = new GetAdminNetAclEntryStatus_OUTPUT();
			uint returnValue = base.Invoke("GetAdminNetAclEntryStatus",input,out output);
			outIsDefault=false;
			if (returnValue == 0)
			{
				if (output.ContainsField("IsDefault"))
					outIsDefault = output.IsDefault;
			}
			return returnValue;
		}
		/// <summary>
		///Enables or disables a user ACL entry.Disabling ACL entries is useful when accounts that cannot be removed (system accounts - starting with $$) are required to be disabled.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class SetAclEnabledState_INPUT : CimParams
		{
			public SetAclEnabledState_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Specifies the ACL entry to update
			/// </summary>
			[CimField(false,true)]
			public virtual uint Handle
			{
				set
				{
					this.SetOrAddField("Handle",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Required, Specifies the state of the ACL entry
			/// </summary>
			[CimField(false,true)]
			public virtual bool Enabled
			{
				set
				{
					this.SetOrAddField("Enabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Enables or disables a user ACL entry.Disabling ACL entries is useful when accounts that cannot be removed (system accounts - starting with $$) are required to be disabled.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class SetAclEnabledState_OUTPUT : CimParams
		{
			public SetAclEnabledState_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Enables or disables a user ACL entry.Disabling ACL entries is useful when accounts that cannot be removed (system accounts - starting with $$) are required to be disabled.
		/// </summary>
		/// <param name="inHandle">Required, IN -Specifies the ACL entry to update</param>
		/// <param name="inEnabled">Required, IN -Specifies the state of the ACL entry</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_NOT_PERMITTED : 16
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// PT_STATUS_INVALID_HANDLE : 2053
		/// PT_STATUS_AUDIT_FAIL : 2075
		/// </returns>
		public virtual uint SetAclEnabledState(uint? inHandle,bool? inEnabled)
		{
			SetAclEnabledState_INPUT input = new SetAclEnabledState_INPUT(this.XmlNamespace);
			if (inHandle.HasValue)
				input.Handle=inHandle.Value;
			if (inEnabled.HasValue)
				input.Enabled=inEnabled.Value;
			SetAclEnabledState_OUTPUT output = new SetAclEnabledState_OUTPUT();
			uint returnValue = base.Invoke("SetAclEnabledState",input,out output);
			return returnValue;
		}
		/// <summary>
		///Gets the state of a user ACL entry (enabled/disabled)
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAclEnabledState_INPUT : CimParams
		{
			public GetAclEnabledState_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Specifies the ACL entry
			/// </summary>
			[CimField(false,true)]
			public virtual uint Handle
			{
				set
				{
					this.SetOrAddField("Handle",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Gets the state of a user ACL entry (enabled/disabled)
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuthorizationService", IsNullable=false)]
		private class GetAclEnabledState_OUTPUT : CimParams
		{
			public GetAclEnabledState_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Required, Specifies the state of the ACL entry
			/// </summary>
			[CimField(false,true)]
			public virtual bool Enabled
			{
				get
				{
					return bool.Parse(this["Enabled"][0]);
				}
			}
		}
		/// <summary>
		///Gets the state of a user ACL entry (enabled/disabled)
		/// </summary>
		/// <param name="inHandle">Required, IN -Specifies the ACL entry</param>
		/// <param name="outEnabled">OUT - Specifies the state of the ACL entry</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_INVALID_HANDLE : 2053
		/// </returns>
		public virtual uint GetAclEnabledState(uint? inHandle,out bool outEnabled)
		{
			GetAclEnabledState_INPUT input = new GetAclEnabledState_INPUT(this.XmlNamespace);
			if (inHandle.HasValue)
				input.Handle=inHandle.Value;
			GetAclEnabledState_OUTPUT output = new GetAclEnabledState_OUTPUT();
			uint returnValue = base.Invoke("GetAclEnabledState",input,out output);
			outEnabled=false;
			if (returnValue == 0)
			{
				if (output.ContainsField("Enabled"))
					outEnabled = output.Enabled;
			}
			return returnValue;
		}

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

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


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


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

		public new class CimKeys : CIM_Service.CimKeys
		{
		}

	}
}